pinata 0.1.9 → 0.2.0

package/dist/index.mjs

@@ -31,21 +31,24 @@ var testAuthentication = async (config) => {
   if (!config || !config.pinataJwt) {
     throw new ValidationError("Pinata configuration or JWT is missing");
   }
-  const headers = {
-    Authorization: `Bearer ${config?.pinataJwt}`
-  };
-  if (config.customHeaders) {
-    Object.assign(headers, config.customHeaders);
+  let headers;
+  let endpoint = "https://api.pinata.cloud";
+  if (config.endpointUrl) {
+    endpoint = config.endpointUrl;
+  }
+  if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
+    headers = { ...config.customHeaders };
+  } else {
+    headers = {
+      Authorization: `Bearer ${config.pinataJwt}`,
+      Source: "sdk/testAuthentication"
+    };
   }
-  headers["Source"] = headers["Source"] || "sdk/testAuthentication";
   try {
-    const request = await fetch(
-      "https://api.pinata.cloud/data/testAuthentication",
-      {
-        method: "GET",
-        headers
-      }
-    );
+    const request = await fetch(`${endpoint}/data/testAuthentication`, {
+      method: "GET",
+      headers
+    });
     if (!request.ok) {
       const errorData = await request.json();
       if (request.status === 401) {
@@ -96,26 +99,29 @@ var uploadFile = async (config, file, options) => {
   data.append(
     "pinataMetadata",
     JSON.stringify({
-      name: options?.metadata ? options.metadata.name : file.name,
+      name: options?.metadata?.name || file.name || "File from SDK",
       keyvalues: options?.metadata?.keyValues
     })
   );
-  const headers = {
-    Authorization: `Bearer ${jwt}`
-  };
-  if (config.customHeaders) {
-    Object.assign(headers, config.customHeaders);
+  let headers;
+  if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
+    headers = { ...config.customHeaders };
+  } else {
+    headers = {
+      Authorization: `Bearer ${jwt}`,
+      Source: "sdk/file"
+    };
+  }
+  let endpoint = "https://api.pinata.cloud";
+  if (config.endpointUrl) {
+    endpoint = config.endpointUrl;
   }
-  headers["Source"] = headers["Source"] || "sdk/file";
   try {
-    const request = await fetch(
-      "https://api.pinata.cloud/pinning/pinFileToIPFS",
-      {
-        method: "POST",
-        headers,
-        body: data
-      }
-    );
+    const request = await fetch(`${endpoint}/pinning/pinFileToIPFS`, {
+      method: "POST",
+      headers,
+      body: data
+    });
     if (!request.ok) {
       const errorData = await request.json();
       if (request.status === 401) {
@@ -150,7 +156,7 @@ var uploadFileArray = async (config, files, options) => {
     throw new ValidationError("Pinata configuration or JWT is missing");
   }
   const jwt = options?.keys || config?.pinataJwt;
-  const folder = options?.metadata?.name ?? "folder_from_sdk";
+  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}`);
@@ -169,22 +175,25 @@ var uploadFileArray = async (config, files, options) => {
       groupId: options?.groupId
     })
   );
-  const headers = {
-    Authorization: `Bearer ${jwt}`
-  };
-  if (config.customHeaders) {
-    Object.assign(headers, config.customHeaders);
+  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;
   }
-  headers["Source"] = headers["Source"] || "sdk/fileArray";
   try {
-    const request = await fetch(
-      "https://api.pinata.cloud/pinning/pinFileToIPFS",
-      {
-        method: "POST",
-        headers,
-        body: data
-      }
-    );
+    const request = await fetch(`${endpoint}/pinning/pinFileToIPFS`, {
+      method: "POST",
+      headers,
+      body: data
+    });
     if (!request.ok) {
       const errorData = await request.json();
       if (request.status === 401) {
@@ -240,22 +249,25 @@ var uploadBase64 = async (config, base64String, options) => {
       keyvalues: options?.metadata?.keyValues
     })
   );
-  const headers = {
-    Authorization: `Bearer ${jwt}`
-  };
-  if (config.customHeaders) {
-    Object.assign(headers, config.customHeaders);
+  let headers;
+  if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
+    headers = { ...config.customHeaders };
+  } else {
+    headers = {
+      Authorization: `Bearer ${jwt}`,
+      Source: "sdk/base64"
+    };
+  }
+  let endpoint = "https://api.pinata.cloud";
+  if (config.endpointUrl) {
+    endpoint = config.endpointUrl;
   }
-  headers["Source"] = headers["Source"] || "sdk/base64";
   try {
-    const request = await fetch(
-      "https://api.pinata.cloud/pinning/pinFileToIPFS",
-      {
-        method: "POST",
-        headers,
-        body: data
-      }
-    );
+    const request = await fetch(`${endpoint}/pinning/pinFileToIPFS`, {
+      method: "POST",
+      headers,
+      body: data
+    });
     if (!request.ok) {
       const errorData = await request.json();
       if (request.status === 401) {
@@ -321,22 +333,25 @@ var uploadUrl = async (config, url, options) => {
       keyvalues: options?.metadata?.keyValues
     })
   );
-  const headers = {
-    Authorization: `Bearer ${jwt}`
-  };
-  if (config.customHeaders) {
-    Object.assign(headers, config.customHeaders);
+  let headers;
+  if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
+    headers = { ...config.customHeaders };
+  } else {
+    headers = {
+      Authorization: `Bearer ${jwt}`,
+      Source: "sdk/url"
+    };
+  }
+  let endpoint = "https://api.pinata.cloud";
+  if (config.endpointUrl) {
+    endpoint = config.endpointUrl;
   }
-  headers["Source"] = headers["Source"] || "sdk/url";
   try {
-    const request = await fetch(
-      "https://api.pinata.cloud/pinning/pinFileToIPFS",
-      {
-        method: "POST",
-        headers,
-        body: data
-      }
-    );
+    const request = await fetch(`${endpoint}/pinning/pinFileToIPFS`, {
+      method: "POST",
+      headers,
+      body: data
+    });
     if (!request.ok) {
       const errorData = await request.json();
       if (request.status === 401) {
@@ -378,27 +393,30 @@ var uploadJson = async (config, jsonData, options) => {
       groupId: options?.groupId
     },
     pinataMetadata: {
-      name: options?.metadata ? options.metadata.name : "json",
+      name: options?.metadata?.name || "json",
       keyvalues: options?.metadata?.keyValues
     }
   });
-  const headers = {
-    "Content-Type": "application/json",
-    Authorization: `Bearer ${jwt}`
-  };
-  if (config.customHeaders) {
-    Object.assign(headers, config.customHeaders);
+  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";
+  if (config.endpointUrl) {
+    endpoint = config.endpointUrl;
   }
-  headers["Source"] = headers["Source"] || "sdk/json";
   try {
-    const request = await fetch(
-      "https://api.pinata.cloud/pinning/pinJSONToIPFS",
-      {
-        method: "POST",
-        headers,
-        body: data
-      }
-    );
+    const request = await fetch(`${endpoint}/pinning/pinJSONToIPFS`, {
+      method: "POST",
+      headers,
+      body: data
+    });
     if (!request.ok) {
       const errorData = await request.json();
       if (request.status === 401) {
@@ -428,23 +446,25 @@ var uploadJson = async (config, jsonData, options) => {
 };
 
 // src/core/pinning/cid.ts
-var uploadCid = async (config, cid2, options) => {
+var uploadCid = async (config, cid, options) => {
   if (!config || !config.pinataJwt) {
     throw new ValidationError("Pinata configuration or JWT is missing");
   }
   const jwt = options?.keys || config?.pinataJwt;
-  const headers = {
-    "Content-Type": "application/json",
-    Authorization: `Bearer ${jwt}`
-  };
-  if (config.customHeaders) {
-    Object.assign(headers, config.customHeaders);
+  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"
+    };
   }
-  headers["Source"] = headers["Source"] || "sdk/cid";
   const data = JSON.stringify({
-    hashToPin: cid2,
+    hashToPin: cid,
     pinataMetadata: {
-      name: options?.metadata ? options?.metadata?.name : cid2,
+      name: options?.metadata ? options?.metadata?.name : cid,
       keyvalues: options?.metadata?.keyValues
     },
     pinataOptions: {
@@ -452,8 +472,12 @@ var uploadCid = async (config, cid2, options) => {
       groupId: options?.groupId
     }
   });
+  let endpoint = "https://api.pinata.cloud";
+  if (config.endpointUrl) {
+    endpoint = config.endpointUrl;
+  }
   try {
-    const request = await fetch("https://api.pinata.cloud/pinning/pinByHash", {
+    const request = await fetch(`${endpoint}/pinning/pinByHash`, {
       method: "POST",
       headers,
       body: data
@@ -497,23 +521,25 @@ var unpinFile = async (config, files) => {
     throw new ValidationError("Pinata configuration or JWT is missing");
   }
   const responses = [];
-  const headers = {
-    "Content-Type": "application/json",
-    Authorization: `Bearer ${config?.pinataJwt}`
-  };
-  if (config.customHeaders) {
-    Object.assign(headers, config.customHeaders);
+  let headers;
+  if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
+    headers = { ...config.customHeaders };
+  } else {
+    headers = {
+      Authorization: `Bearer ${config.pinataJwt}`,
+      Source: "sdk/unpin"
+    };
+  }
+  let endpoint = "https://api.pinata.cloud";
+  if (config.endpointUrl) {
+    endpoint = config.endpointUrl;
   }
-  headers["Source"] = headers["Source"] || "sdk/unpin";
   for (const hash of files) {
     try {
-      const response = await fetch(
-        `https://api.pinata.cloud/pinning/unpin/${hash}`,
-        {
-          method: "DELETE",
-          headers
-        }
-      );
+      const response = await fetch(`${endpoint}/pinning/unpin/${hash}`, {
+        method: "DELETE",
+        headers
+      });
       await wait(300);
       if (!response.ok) {
         const errorData = await response.json();
@@ -563,7 +589,7 @@ var listFiles = async (config, options) => {
   });
   if (options) {
     const {
-      cid: cid2,
+      cid,
       pinStart,
       pinEnd,
       pinSizeMin,
@@ -576,8 +602,8 @@ var listFiles = async (config, options) => {
       operator,
       groupId
     } = options;
-    if (cid2)
-      params.append("cid", cid2);
+    if (cid)
+      params.append("cid", cid);
     if (pinStart)
       params.append("pinStart", pinStart);
     if (pinEnd)
@@ -601,15 +627,21 @@ var listFiles = async (config, options) => {
       params.append("metadata[keyvalues]", keyValueParam);
     }
   }
-  const url = `https://api.pinata.cloud/data/pinList?status=pinned&${params.toString()}`;
+  let endpoint = "https://api.pinata.cloud";
+  if (config.endpointUrl) {
+    endpoint = config.endpointUrl;
+  }
+  const url = `${endpoint}/data/pinList?status=pinned&${params.toString()}`;
   try {
-    const headers = {
-      Authorization: `Bearer ${config?.pinataJwt}`
-    };
-    if (config.customHeaders) {
-      Object.assign(headers, config.customHeaders);
+    let headers;
+    if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
+      headers = { ...config.customHeaders };
+    } else {
+      headers = {
+        Authorization: `Bearer ${config.pinataJwt}`,
+        Source: "sdk/listFiles"
+      };
     }
-    headers["Source"] = headers["Source"] || "sdk/listFiles";
     const request = await fetch(url, {
       method: "GET",
       headers
@@ -652,23 +684,26 @@ var updateMetadata = async (config, options) => {
     name: options.name,
     keyvalues: options.keyValues
   };
-  const headers = {
-    "Content-Type": "application/json",
-    Authorization: `Bearer ${config?.pinataJwt}`
-  };
-  if (config.customHeaders) {
-    Object.assign(headers, config.customHeaders);
+  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/updateMetadata"
+    };
+  }
+  let endpoint = "https://api.pinata.cloud";
+  if (config.endpointUrl) {
+    endpoint = config.endpointUrl;
   }
-  headers["Source"] = headers["Source"] || "sdk/updateMetadata";
   try {
-    const request = await fetch(
-      "https://api.pinata.cloud/pinning/hashMetadata",
-      {
-        method: "PUT",
-        headers,
-        body: JSON.stringify(data)
-      }
-    );
+    const request = await fetch(`${endpoint}/pinning/hashMetadata`, {
+      method: "PUT",
+      headers,
+      body: JSON.stringify(data)
+    });
     if (!request.ok) {
       const errorData = await request.json();
       if (request.status === 401) {
@@ -700,11 +735,18 @@ var updateMetadata = async (config, options) => {
 };
 
 // src/utils/gateway-tools.ts
-import * as isIPFS from "is-ipfs";
-function containsCID(input) {
+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;
@@ -722,11 +764,11 @@ function containsCID(input) {
   } catch (error) {
     const parts = input.split(/\/|\?/);
     for (const part of parts) {
-      const cid2 = startsWithCID(part);
-      if (cid2) {
+      const cid = startsWithCID(part);
+      if (cid) {
         return {
           containsCid: true,
-          cid: cid2
+          cid
         };
       }
     }
@@ -746,11 +788,11 @@ function containsCID(input) {
   }
   const pathParts = url.pathname.split("/");
   for (const part of pathParts) {
-    const cid2 = startsWithCID(part);
-    if (cid2) {
+    const cid = startsWithCID(part);
+    if (cid) {
       return {
         containsCid: true,
-        cid: cid2
+        cid
       };
     }
   }
@@ -759,8 +801,8 @@ function containsCID(input) {
     cid: null
   };
 }
-function convertToDesiredGateway(sourceUrl, desiredGatewayPrefix) {
-  const results = containsCID(sourceUrl);
+async function convertToDesiredGateway(sourceUrl, desiredGatewayPrefix) {
+  const results = await containsCID(sourceUrl);
   if (results.containsCid !== true) {
     throw new Error("url does not contain CID");
   }
@@ -787,13 +829,13 @@ function convertToDesiredGateway(sourceUrl, desiredGatewayPrefix) {
 }
 
 // src/core/gateway/getCid.ts
-var getCid = async (config, cid2) => {
+var getCid = async (config, cid) => {
   if (!config || !config.pinataJwt) {
     throw new ValidationError("Pinata configuration or JWT is missing");
   }
   let data;
   let newUrl;
-  newUrl = convertToDesiredGateway(cid2, config?.pinataGateway);
+  newUrl = await convertToDesiredGateway(cid, config?.pinataGateway);
   if (config?.pinataGatewayKey) {
     newUrl = `${newUrl}?pinataGatewayToken=${config?.pinataGatewayKey}`;
   }
@@ -846,9 +888,9 @@ var getCid = async (config, cid2) => {
 };
 
 // src/core/gateway/convertIPFSUrl.ts
-var convertIPFSUrl = (config, url) => {
+var convertIPFSUrl = async (config, url) => {
   let newUrl;
-  newUrl = convertToDesiredGateway(url, config?.pinataGateway);
+  newUrl = await convertToDesiredGateway(url, config?.pinataGateway);
   if (config?.pinataGatewayKey) {
     `${newUrl}?pinataGatewayToken=${config?.pinataGatewayKey}`;
   }
@@ -864,9 +906,9 @@ var pinJobs = async (config, options) => {
     includesCount: "false"
   });
   if (options) {
-    const { ipfs_pin_hash: cid2, status, sort, limit, offset } = options;
-    if (cid2)
-      params.append("ipfs_pin_hash", cid2.toString());
+    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)
@@ -876,14 +918,20 @@ var pinJobs = async (config, options) => {
     if (offset)
       params.append("offset", offset.toString());
   }
-  const url = `https://api.pinata.cloud/pinning/pinJobs?${params.toString()}`;
-  const headers = {
-    Authorization: `Bearer ${config?.pinataJwt}`
-  };
-  if (config.customHeaders) {
-    Object.assign(headers, config.customHeaders);
+  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"
+    };
   }
-  headers["Source"] = headers["Source"] || "sdk/pinJobs";
   try {
     const request = await fetch(url, {
       method: "GET",
@@ -922,16 +970,21 @@ var pinnedFileCount = async (config) => {
   if (!config || !config.pinataJwt) {
     throw new ValidationError("Pinata configuration or JWT is missing");
   }
-  const url = "https://api.pinata.cloud/data/userPinnedDataTotal";
-  const headers = {
-    Authorization: `Bearer ${config?.pinataJwt}`
-  };
-  if (config.customHeaders) {
-    Object.assign(headers, config.customHeaders);
+  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"
+    };
   }
-  headers["Source"] = headers["Source"] || "sdk/pinnedFileUsage";
   try {
-    const request = await fetch(url, {
+    const request = await fetch(`${endpoint}/data/userPinnedDataTotal`, {
       method: "GET",
       headers
     });
@@ -972,16 +1025,21 @@ var totalStorageUsage = async (config) => {
   if (!config || !config.pinataJwt) {
     throw new ValidationError("Pinata configuration or JWT is missing");
   }
-  const url = "https://api.pinata.cloud/data/userPinnedDataTotal";
-  const headers = {
-    Authorization: `Bearer ${config?.pinataJwt}`
-  };
-  if (config.customHeaders) {
-    Object.assign(headers, config.customHeaders);
+  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"
+    };
   }
-  headers["Source"] = headers["Source"] || "sdk/totalStorageUsage";
   try {
-    const request = await fetch(url, {
+    const request = await fetch(`${endpoint}/data/userPinnedDataTotal`, {
       method: "GET",
       headers
     });
@@ -1022,17 +1080,23 @@ var createKey = async (config, options) => {
   if (!config || !config.pinataJwt) {
     throw new ValidationError("Pinata configuration or JWT is missing");
   }
-  const headers = {
-    "Content-Type": "application/json",
-    Authorization: `Bearer ${config?.pinataJwt}`
-  };
-  if (config.customHeaders) {
-    Object.assign(headers, config.customHeaders);
+  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"
+    };
   }
-  headers["Source"] = headers["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("https://api.pinata.cloud/v3/pinata/keys", {
+    const request = await fetch(`${endpoint}/v3/pinata/keys`, {
       method: "POST",
       headers,
       body: data
@@ -1070,14 +1134,16 @@ var listKeys = async (config, options) => {
   if (!config || !config.pinataJwt) {
     throw new ValidationError("Pinata configuration or JWT is missing");
   }
-  const headers = {
-    "Content-Type": "application/json",
-    Authorization: `Bearer ${config?.pinataJwt}`
-  };
-  if (config.customHeaders) {
-    Object.assign(headers, config.customHeaders);
+  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"
+    };
   }
-  headers["Source"] = headers["Source"] || "sdk/listKeys";
   const params = new URLSearchParams();
   if (options) {
     const { offset, name, revoked, limitedUse, exhausted } = options;
@@ -1092,12 +1158,18 @@ var listKeys = async (config, options) => {
     if (name)
       params.append("name", name);
   }
-  const url = `https://api.pinata.cloud/v3/pinata/keys?${params.toString()}`;
+  let endpoint = "https://api.pinata.cloud";
+  if (config.endpointUrl) {
+    endpoint = config.endpointUrl;
+  }
   try {
-    const request = await fetch(url, {
-      method: "GET",
-      headers
-    });
+    const request = await fetch(
+      `${endpoint}/v3/pinata/keys?${params.toString()}`,
+      {
+        method: "GET",
+        headers
+      }
+    );
     if (!request.ok) {
       const errorData = await request.json();
       if (request.status === 401) {
@@ -1136,24 +1208,27 @@ var revokeKeys = async (config, keys) => {
   if (!config || !config.pinataJwt) {
     throw new ValidationError("Pinata configuration or JWT is missing");
   }
-  const headers = {
-    "Content-Type": "application/json",
-    Authorization: `Bearer ${config?.pinataJwt}`
-  };
-  if (config.customHeaders) {
-    Object.assign(headers, config.customHeaders);
+  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/revokeKeys"
+    };
   }
-  headers["Source"] = headers["Source"] || "sdk/revokeKeys";
   const responses = [];
+  let endpoint = "https://api.pinata.cloud";
+  if (config.endpointUrl) {
+    endpoint = config.endpointUrl;
+  }
   for (const key of keys) {
     try {
-      const request = await fetch(
-        `https://api.pinata.cloud/v3/pinata/keys/${key}`,
-        {
-          method: "PUT",
-          headers
-        }
-      );
+      const request = await fetch(`${endpoint}/v3/pinata/keys/${key}`, {
+        method: "PUT",
+        headers
+      });
       await wait2(300);
       if (!request.ok) {
         const errorData = await request.json();
@@ -1199,16 +1274,22 @@ var createGroup = async (config, options) => {
     throw new ValidationError("Pinata configuration or JWT is missing");
   }
   const data = JSON.stringify(options);
-  const headers = {
-    "Content-Type": "application/json",
-    Authorization: `Bearer ${config?.pinataJwt}`
-  };
-  if (config.customHeaders) {
-    Object.assign(headers, config.customHeaders);
+  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/createGroup"
+    };
+  }
+  let endpoint = "https://api.pinata.cloud";
+  if (config.endpointUrl) {
+    endpoint = config.endpointUrl;
   }
-  headers["Source"] = headers["Source"] || "sdk/createGroup";
   try {
-    const request = await fetch("https://api.pinata.cloud/groups", {
+    const request = await fetch(`${endpoint}/groups`, {
       method: "POST",
       headers,
       body: data
@@ -1246,14 +1327,16 @@ var listGroups = async (config, options) => {
   if (!config || !config.pinataJwt) {
     throw new ValidationError("Pinata configuration or JWT is missing");
   }
-  const headers = {
-    "Content-Type": "application/json",
-    Authorization: `Bearer ${config?.pinataJwt}`
-  };
-  if (config.customHeaders) {
-    Object.assign(headers, config.customHeaders);
+  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/listGroups"
+    };
   }
-  headers["Source"] = headers["Source"] || "sdk/listGroups";
   const params = new URLSearchParams();
   if (options) {
     const { offset, nameContains, limit } = options;
@@ -1264,9 +1347,12 @@ var listGroups = async (config, options) => {
     if (limit !== void 0)
       params.append("limit", limit.toString());
   }
-  const url = `https://api.pinata.cloud/groups?${params.toString()}`;
+  let endpoint = "https://api.pinata.cloud";
+  if (config.endpointUrl) {
+    endpoint = config.endpointUrl;
+  }
   try {
-    const request = await fetch(url, {
+    const request = await fetch(`${endpoint}/groups?${params.toString()}`, {
       method: "GET",
       headers
     });
@@ -1303,22 +1389,25 @@ var getGroup = async (config, options) => {
   if (!config || !config.pinataJwt) {
     throw new ValidationError("Pinata configuration or JWT is missing");
   }
-  const headers = {
-    "Content-Type": "application/json",
-    Authorization: `Bearer ${config?.pinataJwt}`
-  };
-  if (config.customHeaders) {
-    Object.assign(headers, config.customHeaders);
+  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/getGroup"
+    };
+  }
+  let endpoint = "https://api.pinata.cloud";
+  if (config.endpointUrl) {
+    endpoint = config.endpointUrl;
   }
-  headers["Source"] = headers["Source"] || "sdk/getGroup";
   try {
-    const request = await fetch(
-      `https://api.pinata.cloud/groups/${options.groupId}`,
-      {
-        method: "GET",
-        headers
-      }
-    );
+    const request = await fetch(`${endpoint}/groups/${options.groupId}`, {
+      method: "GET",
+      headers
+    });
     if (!request.ok) {
       const errorData = await request.json();
       if (request.status === 401) {
@@ -1357,23 +1446,26 @@ var addToGroup = async (config, options) => {
   const data = JSON.stringify({
     cids: options.cids
   });
-  const headers = {
-    "Content-Type": "application/json",
-    Authorization: `Bearer ${config?.pinataJwt}`
-  };
-  if (config.customHeaders) {
-    Object.assign(headers, config.customHeaders);
+  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;
   }
-  headers["Source"] = headers["Source"] || "sdk/addToGroup";
   try {
-    const request = await fetch(
-      `https://api.pinata.cloud/groups/${options.groupId}/cids`,
-      {
-        method: "PUT",
-        headers,
-        body: data
-      }
-    );
+    const request = await fetch(`${endpoint}/groups/${options.groupId}/cids`, {
+      method: "PUT",
+      headers,
+      body: data
+    });
     if (!request.ok) {
       const errorData = await request.json();
       if (request.status === 401) {
@@ -1412,23 +1504,26 @@ var updateGroup = async (config, options) => {
   const data = JSON.stringify({
     name: options.name
   });
-  const headers = {
-    "Content-Type": "application/json",
-    Authorization: `Bearer ${config?.pinataJwt}`
-  };
-  if (config.customHeaders) {
-    Object.assign(headers, config.customHeaders);
+  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/updateGroup"
+    };
+  }
+  let endpoint = "https://api.pinata.cloud";
+  if (config.endpointUrl) {
+    endpoint = config.endpointUrl;
   }
-  headers["Source"] = headers["Source"] || "sdk/updateGroup";
   try {
-    const request = await fetch(
-      `https://api.pinata.cloud/groups/${options.groupId}`,
-      {
-        method: "PUT",
-        headers,
-        body: data
-      }
-    );
+    const request = await fetch(`${endpoint}/groups/${options.groupId}`, {
+      method: "PUT",
+      headers,
+      body: data
+    });
     if (!request.ok) {
       const errorData = await request.json();
       if (request.status === 401) {
@@ -1462,26 +1557,29 @@ var removeFromGroup = async (config, options) => {
   if (!config || !config.pinataJwt) {
     throw new ValidationError("Pinata configuration or JWT is missing");
   }
-  const headers = {
-    "Content-Type": "application/json",
-    Authorization: `Bearer ${config?.pinataJwt}`
-  };
-  if (config.customHeaders) {
-    Object.assign(headers, config.customHeaders);
+  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"
+    };
   }
-  headers["Source"] = headers["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(
-      `https://api.pinata.cloud/groups/${options.groupId}/cids`,
-      {
-        method: "DELETE",
-        headers,
-        body: data
-      }
-    );
+    const request = await fetch(`${endpoint}/groups/${options.groupId}/cids`, {
+      method: "DELETE",
+      headers,
+      body: data
+    });
     if (!request.ok) {
       const errorData = await request.json();
       if (request.status === 401) {
@@ -1519,22 +1617,25 @@ var deleteGroup = async (config, options) => {
   if (!config || !config.pinataJwt) {
     throw new ValidationError("Pinata configuration or JWT is missing");
   }
-  const headers = {
-    "Content-Type": "application/json",
-    Authorization: `Bearer ${config?.pinataJwt}`
-  };
-  if (config.customHeaders) {
-    Object.assign(headers, config.customHeaders);
+  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;
   }
-  headers["Source"] = headers["Source"] || "sdk/deleteGroup";
   try {
-    const request = await fetch(
-      `https://api.pinata.cloud/groups/${options.groupId}`,
-      {
-        method: "DELETE",
-        headers
-      }
-    );
+    const request = await fetch(`${endpoint}/groups/${options.groupId}`, {
+      method: "DELETE",
+      headers
+    });
     if (!request.ok) {
       const errorData = await request.json();
       if (request.status === 401) {
@@ -1571,17 +1672,23 @@ var addSignature = async (config, options) => {
   const data = JSON.stringify({
     signature: options.signature
   });
-  const headers = {
-    "Content-Type": "application/json",
-    Authorization: `Bearer ${config?.pinataJwt}`
-  };
-  if (config.customHeaders) {
-    Object.assign(headers, config.customHeaders);
+  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;
   }
-  headers["Source"] = headers["Source"] || "sdk/addSignature";
   try {
     const request = await fetch(
-      `https://api.pinata.cloud/v3/ipfs/signature/${options.cid}`,
+      `${endpoint}/v3/ipfs/signature/${options.cid}`,
       {
         method: "POST",
         headers,
@@ -1626,26 +1733,29 @@ var addSignature = async (config, options) => {
 };
 
 // src/core/signatures/getSignature.ts
-var getSignature = async (config, cid2) => {
+var getSignature = async (config, cid) => {
   if (!config || !config.pinataJwt) {
     throw new ValidationError("Pinata configuration or JWT is missing");
   }
-  const headers = {
-    "Content-Type": "application/json",
-    Authorization: `Bearer ${config?.pinataJwt}`
-  };
-  if (config.customHeaders) {
-    Object.assign(headers, config.customHeaders);
+  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;
   }
-  headers["Source"] = headers["Source"] || "sdk/getSignature";
   try {
-    const request = await fetch(
-      `https://api.pinata.cloud/v3/ipfs/signature/${cid2}`,
-      {
-        method: "GET",
-        headers
-      }
-    );
+    const request = await fetch(`${endpoint}/v3/ipfs/signature/${cid}`, {
+      method: "GET",
+      headers
+    });
     if (!request.ok) {
       const errorData = await request.json();
       if (request.status === 401) {
@@ -1677,26 +1787,29 @@ var getSignature = async (config, cid2) => {
 };
 
 // src/core/signatures/removeSignature.ts
-var removeSignature = async (config, cid2) => {
+var removeSignature = async (config, cid) => {
   if (!config || !config.pinataJwt) {
     throw new ValidationError("Pinata configuration or JWT is missing");
   }
-  const headers = {
-    "Content-Type": "application/json",
-    Authorization: `Bearer ${config?.pinataJwt}`
-  };
-  if (config.customHeaders) {
-    Object.assign(headers, config.customHeaders);
+  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;
   }
-  headers["Source"] = headers["Source"] || "sdk/removeSignature";
   try {
-    const request = await fetch(
-      `https://api.pinata.cloud/v3/ipfs/signature/${cid2}`,
-      {
-        method: "DELETE",
-        headers
-      }
-    );
+    const request = await fetch(`${endpoint}/v3/ipfs/signature/${cid}`, {
+      method: "DELETE",
+      headers
+    });
     if (!request.ok) {
       const errorData = await request.json();
       if (request.status === 401) {
@@ -1726,6 +1839,210 @@ var removeSignature = async (config, cid2) => {
   }
 };
 
+// src/core/gateway/analyticsTopUsage.ts
+var analyticsTopUsage = async (config, options) => {
+  if (!config || !config.pinataJwt) {
+    throw new ValidationError("Pinata configuration or JWT 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.json();
+      if (request.status === 401) {
+        throw new AuthenticationError(
+          "Authentication failed",
+          request.status,
+          errorData
+        );
+      }
+      throw new NetworkError(
+        `HTTP error! status: ${request.status}`,
+        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 || !config.pinataJwt) {
+    throw new ValidationError("Pinata configuration or JWT 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.json();
+      if (request.status === 401) {
+        throw new AuthenticationError(
+          "Authentication failed",
+          request.status,
+          errorData
+        );
+      }
+      throw new NetworkError(
+        `HTTP error! status: ${request.status}`,
+        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/pinataSDK.ts
 var formatConfig = (config) => {
   let gateway = config?.pinataGateway;
@@ -1747,6 +2064,18 @@ var PinataSDK = class {
     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.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);
   }
@@ -1818,6 +2147,9 @@ var Upload = class {
   constructor(config) {
     this.config = formatConfig(config);
   }
+  updateConfig(newConfig) {
+    this.config = newConfig;
+  }
   file(file, options) {
     return new UploadBuilder(this.config, uploadFile, file, options);
   }
@@ -1833,8 +2165,8 @@ var Upload = class {
   json(data, options) {
     return new UploadBuilder(this.config, uploadJson, data, options);
   }
-  cid(cid2, options) {
-    return new UploadBuilder(this.config, uploadCid, cid2, options);
+  cid(cid, options) {
+    return new UploadBuilder(this.config, uploadCid, cid, options);
   }
 };
 var FilterFiles = class {
@@ -1847,8 +2179,8 @@ var FilterFiles = class {
     this.MINUTE_IN_MS = 6e4;
     this.config = config;
   }
-  cid(cid2) {
-    this.query.cid = cid2;
+  cid(cid) {
+    this.query.cid = cid;
     return this;
   }
   pinStart(date) {
@@ -1939,12 +2271,34 @@ var Gateways = class {
   constructor(config) {
     this.config = formatConfig(config);
   }
-  get(cid2) {
-    return getCid(this.config, cid2);
+  updateConfig(newConfig) {
+    this.config = newConfig;
+  }
+  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
+    );
+  }
 };
 var FilterPinJobs = class {
   constructor(config) {
@@ -1956,8 +2310,8 @@ var FilterPinJobs = class {
     this.MINUTE_IN_MS = 6e4;
     this.config = config;
   }
-  cid(cid2) {
-    this.query.ipfs_pin_hash = cid2;
+  cid(cid) {
+    this.query.ipfs_pin_hash = cid;
     return this;
   }
   status(status) {
@@ -2024,6 +2378,9 @@ var Usage = class {
   constructor(config) {
     this.config = formatConfig(config);
   }
+  updateConfig(newConfig) {
+    this.config = newConfig;
+  }
   pinnedFileCount() {
     return pinnedFileCount(this.config);
   }
@@ -2035,6 +2392,9 @@ var Keys = class {
   constructor(config) {
     this.config = formatConfig(config);
   }
+  updateConfig(newConfig) {
+    this.config = newConfig;
+  }
   create(options) {
     return createKey(this.config, options);
   }
@@ -2121,6 +2481,9 @@ var Groups = class {
   constructor(config) {
     this.config = formatConfig(config);
   }
+  updateConfig(newConfig) {
+    this.config = newConfig;
+  }
   create(options) {
     return createGroup(this.config, options);
   }
@@ -2211,14 +2574,116 @@ var Signatures = class {
   constructor(config) {
     this.config = formatConfig(config);
   }
+  updateConfig(newConfig) {
+    this.config = newConfig;
+  }
   add(options) {
     return addSignature(this.config, options);
   }
-  get(cid2) {
-    return getSignature(this.config, cid2);
+  get(cid) {
+    return getSignature(this.config, cid);
   }
-  delete(cid2) {
-    return removeSignature(this.config, cid2);
+  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();
   }
 };
 export {