pinata 2.5.2 → 2.5.4

package/dist/index.mjs

@@ -884,9 +884,9 @@ var updateFile = async (config, options, privacy) => {
   if (!config) {
     throw new ValidationError("Pinata configuration is missing");
   }
-  if (!options.name && (!options.keyvalues || Object.keys(options.keyvalues).length === 0)) {
+  if (!options.name && (!options.keyvalues || Object.keys(options.keyvalues).length === 0) && options.expires_at === void 0) {
     throw new ValidationError(
-      "At least one of 'name' or 'keyvalues' must be provided"
+      "At least one of 'name', 'keyvalues', or 'expires_at' must be provided"
     );
   }
   const data = {};
@@ -896,6 +896,9 @@ var updateFile = async (config, options, privacy) => {
   if (options.keyvalues && Object.keys(options.keyvalues).length > 0) {
     data.keyvalues = options.keyvalues;
   }
+  if (options.expires_at !== void 0) {
+    data.expires_at = options.expires_at;
+  }
   const body = JSON.stringify(data);
   let headers;
   if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
@@ -2558,6 +2561,9 @@ var uploadFile = async (config, file, network, options) => {
     if (options?.cid_version !== void 0) {
       metadata += `,cid_version ${btoa(options.cid_version)}`;
     }
+    if (options?.expires_at !== void 0) {
+      metadata += `,expires_at ${btoa(options.expires_at.toString())}`;
+    }
     let updatedEndpoint = `${endpoint}/files`;
     if (options?.url) {
       updatedEndpoint = options.url;
@@ -2734,6 +2740,9 @@ var uploadFile = async (config, file, network, options) => {
   if (options?.cid_version !== void 0) {
     data.append("cid_version", options.cid_version.toString());
   }
+  if (options?.expires_at !== void 0) {
+    data.append("expires_at", options.expires_at.toString());
+  }
   if (options?.url) {
     try {
       const url = new URL(options.url);
@@ -3351,156 +3360,750 @@ var uploadCid = async (config, cid, options) => {
   }
 };
 
-// src/core/classes/analytics/Analytics.ts
-var Analytics = class {
-  constructor(config) {
-    this.config = formatConfig(config);
-    this.requests = new AnalyticsRequests(this.config);
-    this.bandwidth = new AnalyticsBandwidth(this.config);
-  }
-  updateConfig(newConfig) {
-    this.config = newConfig;
-    this.requests.updateConfig(newConfig);
-    this.bandwidth.updateConfig(newConfig);
-  }
-  summary(options) {
-    return new TimeIntervalAnalyticsBuilder(
-      this.config,
-      options.domain,
-      options.start,
-      options.end,
-      options.interval
-    );
+// src/core/functions/x402/listPaymentInstructions.ts
+var listPaymentInstructions = async (config, options) => {
+  if (!config) {
+    throw new ValidationError("Pinata configuration is missing");
   }
-};
-
-// src/core/classes/analytics/utils.ts
-var calculateDates = (days) => {
-  const end = /* @__PURE__ */ new Date();
-  const start = /* @__PURE__ */ new Date();
-  start.setDate(start.getDate() - days);
-  return {
-    start: start.toISOString().split("T")[0],
-    end: end.toISOString().split("T")[0]
-  };
-};
-
-// src/core/classes/analytics/AnalyticsFilter.ts
-var AnalyticsFilter = class {
-  constructor(config, domain, start, end) {
-    this.config = config;
-    this.query = {
-      gateway_domain: domain,
-      start_date: start,
-      end_date: end,
-      sort_by: "requests",
-      // Will be overridden in child classes
-      attribute: "cid"
+  let headers;
+  if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
+    headers = {
+      Authorization: `Bearer ${config.pinataJwt}`,
+      "Content-Type": "application/json",
+      ...config.customHeaders
+    };
+  } else {
+    headers = {
+      Authorization: `Bearer ${config.pinataJwt}`,
+      "Content-Type": "application/json",
+      Source: "sdk/listPaymentInstructions"
     };
   }
-  cid(cid) {
-    this.query.attribute = "cid";
-    if (cid) {
-      this.query.cid = cid;
-    }
-    return this;
-  }
-  fileName(fileName) {
-    this.query.attribute = "file_name";
-    if (fileName) {
-      this.query.file_name = fileName;
-    }
-    return this;
+  const params = new URLSearchParams();
+  if (options) {
+    const { pageToken, limit, cid, name, id } = options;
+    if (pageToken) params.append("pageToken", pageToken);
+    if (limit !== void 0) params.append("limit", limit.toString());
+    if (cid) params.append("cid", cid);
+    if (name) params.append("name", name);
+    if (id) params.append("id", id);
   }
-  userAgent(userAgent) {
-    this.query.attribute = "user_agent";
-    if (userAgent) {
-      this.query.user_agent = userAgent;
-    }
-    return this;
+  let endpoint = "https://api.pinata.cloud/v3";
+  if (config.endpointUrl) {
+    endpoint = config.endpointUrl;
   }
-  country(country) {
-    this.query.attribute = "country";
-    if (country) {
-      this.query.country = country;
+  try {
+    const request = await fetch(
+      `${endpoint}/x402/payment_instructions?${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,
+          {
+            error: errorData,
+            code: "AUTH_ERROR",
+            metadata: {
+              requestUrl: request.url
+            }
+          }
+        );
+      }
+      throw new NetworkError(`HTTP error: ${errorData}`, request.status, {
+        error: errorData,
+        code: "HTTP_ERROR",
+        metadata: {
+          requestUrl: request.url
+        }
+      });
     }
-    return this;
-  }
-  region(region) {
-    this.query.attribute = "region";
-    if (region) {
-      this.query.region = region;
+    const res = await request.json();
+    return res;
+  } catch (error) {
+    if (error instanceof PinataError) {
+      throw error;
     }
-    return this;
-  }
-  referer(referer) {
-    this.query.attribute = "referer";
-    if (referer) {
-      this.query.referer = referer;
+    if (error instanceof Error) {
+      throw new PinataError(
+        `Error processing listPaymentInstructions: ${error.message}`
+      );
     }
-    return this;
-  }
-  limit(limit) {
-    this.query.limit = limit;
-    return this;
-  }
-  sort(order) {
-    this.query.sort_order = order;
-    return this;
-  }
-  days(numberOfDays) {
-    const { start, end } = calculateDates(numberOfDays);
-    this.query.start_date = start;
-    this.query.end_date = end;
-    return this;
-  }
-  then(onfulfilled, onrejected) {
-    return analyticsTopUsage(this.config, this.query).then(
-      onfulfilled,
-      onrejected
+    throw new PinataError(
+      "An unknown error occurred while listing payment instructions"
     );
   }
 };
 
-// src/core/classes/analytics/AnalyticsBandwidth.ts
-var AnalyticsBandwidth = class extends AnalyticsFilter {
-  constructor(config) {
-    super(config, "", "", "");
-    this.query.sort_by = "bandwidth";
+// src/core/functions/x402/createPaymentInstruction.ts
+var createPaymentInstruction = async (config, request) => {
+  if (!config) {
+    throw new ValidationError("Pinata configuration is missing");
   }
-  updateConfig(newConfig) {
-    this.config = newConfig;
+  if (!request.name) {
+    throw new ValidationError("Payment instruction name is required");
   }
-  customDates(start, end) {
-    if (start) this.query.start_date = start;
-    if (end) this.query.end_date = end;
-    return this;
+  if (!request.payment_requirements || request.payment_requirements.length === 0) {
+    throw new ValidationError("At least one payment requirement is required");
   }
-  from(domain) {
-    this.query.gateway_domain = domain;
-    return this;
+  let headers;
+  if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
+    headers = {
+      Authorization: `Bearer ${config.pinataJwt}`,
+      "Content-Type": "application/json",
+      ...config.customHeaders
+    };
+  } else {
+    headers = {
+      Authorization: `Bearer ${config.pinataJwt}`,
+      "Content-Type": "application/json",
+      Source: "sdk/createPaymentInstruction"
+    };
+  }
+  let endpoint = "https://api.pinata.cloud/v3";
+  if (config.endpointUrl) {
+    endpoint = config.endpointUrl;
+  }
+  try {
+    const requestObj = await fetch(`${endpoint}/x402/payment_instructions`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(request)
+    });
+    if (!requestObj.ok) {
+      const errorData = await requestObj.text();
+      if (requestObj.status === 401 || requestObj.status === 403) {
+        throw new AuthenticationError(
+          `Authentication failed: ${errorData}`,
+          requestObj.status,
+          {
+            error: errorData,
+            code: "AUTH_ERROR",
+            metadata: {
+              requestUrl: requestObj.url
+            }
+          }
+        );
+      }
+      throw new NetworkError(`HTTP error: ${errorData}`, requestObj.status, {
+        error: errorData,
+        code: "HTTP_ERROR",
+        metadata: {
+          requestUrl: requestObj.url
+        }
+      });
+    }
+    const res = await requestObj.json();
+    return res;
+  } catch (error) {
+    if (error instanceof PinataError) {
+      throw error;
+    }
+    if (error instanceof Error) {
+      throw new PinataError(
+        `Error processing createPaymentInstruction: ${error.message}`
+      );
+    }
+    throw new PinataError(
+      "An unknown error occurred while creating payment instruction"
+    );
   }
 };
 
-// src/core/classes/analytics/AnalyticsBuilder.ts
-var AnalyticsBuilder = 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;
+// src/core/functions/x402/getPaymentInstruction.ts
+var getPaymentInstruction = async (config, id) => {
+  if (!config) {
+    throw new ValidationError("Pinata configuration is missing");
   }
-  cid(cid) {
-    this.query.cid = cid;
-    return this;
+  if (!id) {
+    throw new ValidationError("Payment instruction ID is required");
   }
-  fileName(fileName) {
-    this.query.file_name = fileName;
-    return this;
+  let headers;
+  if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
+    headers = {
+      Authorization: `Bearer ${config.pinataJwt}`,
+      "Content-Type": "application/json",
+      ...config.customHeaders
+    };
+  } else {
+    headers = {
+      Authorization: `Bearer ${config.pinataJwt}`,
+      "Content-Type": "application/json",
+      Source: "sdk/getPaymentInstruction"
+    };
   }
-  userAgent(userAgent) {
+  let endpoint = "https://api.pinata.cloud/v3";
+  if (config.endpointUrl) {
+    endpoint = config.endpointUrl;
+  }
+  try {
+    const request = await fetch(`${endpoint}/x402/payment_instructions/${id}`, {
+      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,
+          {
+            error: errorData,
+            code: "AUTH_ERROR",
+            metadata: {
+              requestUrl: request.url
+            }
+          }
+        );
+      }
+      throw new NetworkError(`HTTP error: ${errorData}`, request.status, {
+        error: errorData,
+        code: "HTTP_ERROR",
+        metadata: {
+          requestUrl: request.url
+        }
+      });
+    }
+    const res = await request.json();
+    return res;
+  } catch (error) {
+    if (error instanceof PinataError) {
+      throw error;
+    }
+    if (error instanceof Error) {
+      throw new PinataError(
+        `Error processing getPaymentInstruction: ${error.message}`
+      );
+    }
+    throw new PinataError(
+      "An unknown error occurred while getting payment instruction"
+    );
+  }
+};
+
+// src/core/functions/x402/updatePaymentInstruction.ts
+var updatePaymentInstruction = async (config, id, request) => {
+  if (!config) {
+    throw new ValidationError("Pinata configuration is missing");
+  }
+  if (!id) {
+    throw new ValidationError("Payment instruction ID is required");
+  }
+  let headers;
+  if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
+    headers = {
+      Authorization: `Bearer ${config.pinataJwt}`,
+      "Content-Type": "application/json",
+      ...config.customHeaders
+    };
+  } else {
+    headers = {
+      Authorization: `Bearer ${config.pinataJwt}`,
+      "Content-Type": "application/json",
+      Source: "sdk/updatePaymentInstruction"
+    };
+  }
+  let endpoint = "https://api.pinata.cloud/v3";
+  if (config.endpointUrl) {
+    endpoint = config.endpointUrl;
+  }
+  try {
+    const requestObj = await fetch(
+      `${endpoint}/x402/payment_instructions/${id}`,
+      {
+        method: "PATCH",
+        headers,
+        body: JSON.stringify(request)
+      }
+    );
+    if (!requestObj.ok) {
+      const errorData = await requestObj.text();
+      if (requestObj.status === 401 || requestObj.status === 403) {
+        throw new AuthenticationError(
+          `Authentication failed: ${errorData}`,
+          requestObj.status,
+          {
+            error: errorData,
+            code: "AUTH_ERROR",
+            metadata: {
+              requestUrl: requestObj.url
+            }
+          }
+        );
+      }
+      throw new NetworkError(`HTTP error: ${errorData}`, requestObj.status, {
+        error: errorData,
+        code: "HTTP_ERROR",
+        metadata: {
+          requestUrl: requestObj.url
+        }
+      });
+    }
+    const res = await requestObj.json();
+    return res;
+  } catch (error) {
+    if (error instanceof PinataError) {
+      throw error;
+    }
+    if (error instanceof Error) {
+      throw new PinataError(
+        `Error processing updatePaymentInstruction: ${error.message}`
+      );
+    }
+    throw new PinataError(
+      "An unknown error occurred while updating payment instruction"
+    );
+  }
+};
+
+// src/core/functions/x402/deletePaymentInstruction.ts
+var deletePaymentInstruction = async (config, id) => {
+  if (!config) {
+    throw new ValidationError("Pinata configuration is missing");
+  }
+  if (!id) {
+    throw new ValidationError("Payment instruction ID is required");
+  }
+  let headers;
+  if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
+    headers = {
+      Authorization: `Bearer ${config.pinataJwt}`,
+      "Content-Type": "application/json",
+      ...config.customHeaders
+    };
+  } else {
+    headers = {
+      Authorization: `Bearer ${config.pinataJwt}`,
+      "Content-Type": "application/json",
+      Source: "sdk/deletePaymentInstruction"
+    };
+  }
+  let endpoint = "https://api.pinata.cloud/v3";
+  if (config.endpointUrl) {
+    endpoint = config.endpointUrl;
+  }
+  try {
+    const request = await fetch(`${endpoint}/x402/payment_instructions/${id}`, {
+      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,
+          {
+            error: errorData,
+            code: "AUTH_ERROR",
+            metadata: {
+              requestUrl: request.url
+            }
+          }
+        );
+      }
+      throw new NetworkError(`HTTP error: ${errorData}`, request.status, {
+        error: errorData,
+        code: "HTTP_ERROR",
+        metadata: {
+          requestUrl: request.url
+        }
+      });
+    }
+    const res = await request.json();
+    return res;
+  } catch (error) {
+    if (error instanceof PinataError) {
+      throw error;
+    }
+    if (error instanceof Error) {
+      throw new PinataError(
+        `Error processing deletePaymentInstruction: ${error.message}`
+      );
+    }
+    throw new PinataError(
+      "An unknown error occurred while deleting payment instruction"
+    );
+  }
+};
+
+// src/core/functions/x402/listCids.ts
+var listCids = async (config, paymentInstructionId, options) => {
+  if (!config) {
+    throw new ValidationError("Pinata configuration is missing");
+  }
+  if (!paymentInstructionId) {
+    throw new ValidationError("Payment instruction ID is required");
+  }
+  let headers;
+  if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
+    headers = {
+      Authorization: `Bearer ${config.pinataJwt}`,
+      "Content-Type": "application/json",
+      ...config.customHeaders
+    };
+  } else {
+    headers = {
+      Authorization: `Bearer ${config.pinataJwt}`,
+      "Content-Type": "application/json",
+      Source: "sdk/listCids"
+    };
+  }
+  const params = new URLSearchParams();
+  if (options) {
+    const { pageToken, limit } = options;
+    if (pageToken) params.append("pageToken", pageToken);
+    if (limit !== void 0) params.append("limit", limit.toString());
+  }
+  let endpoint = "https://api.pinata.cloud/v3";
+  if (config.endpointUrl) {
+    endpoint = config.endpointUrl;
+  }
+  try {
+    const request = await fetch(
+      `${endpoint}/x402/payment_instructions/${paymentInstructionId}/cids?${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,
+          {
+            error: errorData,
+            code: "AUTH_ERROR",
+            metadata: {
+              requestUrl: request.url
+            }
+          }
+        );
+      }
+      throw new NetworkError(`HTTP error: ${errorData}`, request.status, {
+        error: errorData,
+        code: "HTTP_ERROR",
+        metadata: {
+          requestUrl: request.url
+        }
+      });
+    }
+    const res = await request.json();
+    return res;
+  } catch (error) {
+    if (error instanceof PinataError) {
+      throw error;
+    }
+    if (error instanceof Error) {
+      throw new PinataError(`Error processing listCids: ${error.message}`);
+    }
+    throw new PinataError("An unknown error occurred while listing CIDs");
+  }
+};
+
+// src/core/functions/x402/addCid.ts
+var addCid = async (config, paymentInstructionId, cid) => {
+  if (!config) {
+    throw new ValidationError("Pinata configuration is missing");
+  }
+  if (!paymentInstructionId) {
+    throw new ValidationError("Payment instruction ID is required");
+  }
+  if (!cid) {
+    throw new ValidationError("CID is required");
+  }
+  let headers;
+  if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
+    headers = {
+      Authorization: `Bearer ${config.pinataJwt}`,
+      "Content-Type": "application/json",
+      ...config.customHeaders
+    };
+  } else {
+    headers = {
+      Authorization: `Bearer ${config.pinataJwt}`,
+      "Content-Type": "application/json",
+      Source: "sdk/addCid"
+    };
+  }
+  let endpoint = "https://api.pinata.cloud/v3";
+  if (config.endpointUrl) {
+    endpoint = config.endpointUrl;
+  }
+  try {
+    const request = await fetch(
+      `${endpoint}/x402/payment_instructions/${paymentInstructionId}/cids/${cid}`,
+      {
+        method: "PUT",
+        headers
+      }
+    );
+    if (!request.ok) {
+      const errorData = await request.text();
+      if (request.status === 401 || request.status === 403) {
+        throw new AuthenticationError(
+          `Authentication failed: ${errorData}`,
+          request.status,
+          {
+            error: errorData,
+            code: "AUTH_ERROR",
+            metadata: {
+              requestUrl: request.url
+            }
+          }
+        );
+      }
+      throw new NetworkError(`HTTP error: ${errorData}`, request.status, {
+        error: errorData,
+        code: "HTTP_ERROR",
+        metadata: {
+          requestUrl: request.url
+        }
+      });
+    }
+    const res = await request.json();
+    return res;
+  } catch (error) {
+    if (error instanceof PinataError) {
+      throw error;
+    }
+    if (error instanceof Error) {
+      throw new PinataError(`Error processing addCid: ${error.message}`);
+    }
+    throw new PinataError("An unknown error occurred while adding CID");
+  }
+};
+
+// src/core/functions/x402/removeCid.ts
+var removeCid = async (config, paymentInstructionId, cid) => {
+  if (!config) {
+    throw new ValidationError("Pinata configuration is missing");
+  }
+  if (!paymentInstructionId) {
+    throw new ValidationError("Payment instruction ID is required");
+  }
+  if (!cid) {
+    throw new ValidationError("CID is required");
+  }
+  let headers;
+  if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
+    headers = {
+      Authorization: `Bearer ${config.pinataJwt}`,
+      "Content-Type": "application/json",
+      ...config.customHeaders
+    };
+  } else {
+    headers = {
+      Authorization: `Bearer ${config.pinataJwt}`,
+      "Content-Type": "application/json",
+      Source: "sdk/removeCid"
+    };
+  }
+  let endpoint = "https://api.pinata.cloud/v3";
+  if (config.endpointUrl) {
+    endpoint = config.endpointUrl;
+  }
+  try {
+    const request = await fetch(
+      `${endpoint}/x402/payment_instructions/${paymentInstructionId}/cids/${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,
+          {
+            error: errorData,
+            code: "AUTH_ERROR",
+            metadata: {
+              requestUrl: request.url
+            }
+          }
+        );
+      }
+      throw new NetworkError(`HTTP error: ${errorData}`, request.status, {
+        error: errorData,
+        code: "HTTP_ERROR",
+        metadata: {
+          requestUrl: request.url
+        }
+      });
+    }
+    const res = await request.json();
+    return res;
+  } catch (error) {
+    if (error instanceof PinataError) {
+      throw error;
+    }
+    if (error instanceof Error) {
+      throw new PinataError(`Error processing removeCid: ${error.message}`);
+    }
+    throw new PinataError("An unknown error occurred while removing CID");
+  }
+};
+
+// src/core/classes/analytics/Analytics.ts
+var Analytics = class {
+  constructor(config) {
+    this.config = formatConfig(config);
+    this.requests = new AnalyticsRequests(this.config);
+    this.bandwidth = new AnalyticsBandwidth(this.config);
+  }
+  updateConfig(newConfig) {
+    this.config = newConfig;
+    this.requests.updateConfig(newConfig);
+    this.bandwidth.updateConfig(newConfig);
+  }
+  summary(options) {
+    return new TimeIntervalAnalyticsBuilder(
+      this.config,
+      options.domain,
+      options.start,
+      options.end,
+      options.interval
+    );
+  }
+};
+
+// src/core/classes/analytics/utils.ts
+var calculateDates = (days) => {
+  const end = /* @__PURE__ */ new Date();
+  const start = /* @__PURE__ */ new Date();
+  start.setDate(start.getDate() - days);
+  return {
+    start: start.toISOString().split("T")[0],
+    end: end.toISOString().split("T")[0]
+  };
+};
+
+// src/core/classes/analytics/AnalyticsFilter.ts
+var AnalyticsFilter = class {
+  constructor(config, domain, start, end) {
+    this.config = config;
+    this.query = {
+      gateway_domain: domain,
+      start_date: start,
+      end_date: end,
+      sort_by: "requests",
+      // Will be overridden in child classes
+      attribute: "cid"
+    };
+  }
+  cid(cid) {
+    this.query.attribute = "cid";
+    if (cid) {
+      this.query.cid = cid;
+    }
+    return this;
+  }
+  fileName(fileName) {
+    this.query.attribute = "file_name";
+    if (fileName) {
+      this.query.file_name = fileName;
+    }
+    return this;
+  }
+  userAgent(userAgent) {
+    this.query.attribute = "user_agent";
+    if (userAgent) {
+      this.query.user_agent = userAgent;
+    }
+    return this;
+  }
+  country(country) {
+    this.query.attribute = "country";
+    if (country) {
+      this.query.country = country;
+    }
+    return this;
+  }
+  region(region) {
+    this.query.attribute = "region";
+    if (region) {
+      this.query.region = region;
+    }
+    return this;
+  }
+  referer(referer) {
+    this.query.attribute = "referer";
+    if (referer) {
+      this.query.referer = referer;
+    }
+    return this;
+  }
+  limit(limit) {
+    this.query.limit = limit;
+    return this;
+  }
+  sort(order) {
+    this.query.sort_order = order;
+    return this;
+  }
+  days(numberOfDays) {
+    const { start, end } = calculateDates(numberOfDays);
+    this.query.start_date = start;
+    this.query.end_date = end;
+    return this;
+  }
+  then(onfulfilled, onrejected) {
+    return analyticsTopUsage(this.config, this.query).then(
+      onfulfilled,
+      onrejected
+    );
+  }
+};
+
+// src/core/classes/analytics/AnalyticsBandwidth.ts
+var AnalyticsBandwidth = class extends AnalyticsFilter {
+  constructor(config) {
+    super(config, "", "", "");
+    this.query.sort_by = "bandwidth";
+  }
+  updateConfig(newConfig) {
+    this.config = newConfig;
+  }
+  customDates(start, end) {
+    if (start) this.query.start_date = start;
+    if (end) this.query.end_date = end;
+    return this;
+  }
+  from(domain) {
+    this.query.gateway_domain = domain;
+    return this;
+  }
+};
+
+// src/core/classes/analytics/AnalyticsBuilder.ts
+var AnalyticsBuilder = 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;
   }
@@ -4688,6 +5291,40 @@ var Signatures = class {
   }
 };
 
+// src/core/classes/x402/X402.ts
+var X402 = class {
+  constructor(config) {
+    this.config = formatConfig(config);
+  }
+  updateConfig(newConfig) {
+    this.config = newConfig;
+  }
+  listPaymentInstructions(options) {
+    return listPaymentInstructions(this.config, options);
+  }
+  createPaymentInstruction(request) {
+    return createPaymentInstruction(this.config, request);
+  }
+  getPaymentInstruction(id) {
+    return getPaymentInstruction(this.config, id);
+  }
+  updatePaymentInstruction(id, request) {
+    return updatePaymentInstruction(this.config, id, request);
+  }
+  deletePaymentInstruction(id) {
+    return deletePaymentInstruction(this.config, id);
+  }
+  listCids(paymentInstructionId, options) {
+    return listCids(this.config, paymentInstructionId, options);
+  }
+  addCid(paymentInstructionId, cid) {
+    return addCid(this.config, paymentInstructionId, cid);
+  }
+  removeCid(paymentInstructionId, cid) {
+    return removeCid(this.config, paymentInstructionId, cid);
+  }
+};
+
 // src/core/pinataSDK.ts
 var PinataSDK = class {
   constructor(config) {
@@ -4699,6 +5336,7 @@ var PinataSDK = class {
     this.groups = new Groups(this.config);
     this.analytics = new Analytics(this.config);
     this.signatures = new Signatures(this.config);
+    this.x402 = new X402(this.config);
   }
   setNewHeaders(headers) {
     if (!this.config) {
@@ -4712,6 +5350,7 @@ var PinataSDK = class {
     this.groups.updateConfig(this.config);
     this.analytics.updateConfig(this.config);
     this.signatures.updateConfig(this.config);
+    this.x402.updateConfig(this.config);
   }
   setNewJwt(jwt) {
     if (!this.config) {
@@ -4725,12 +5364,13 @@ var PinataSDK = class {
     this.groups.updateConfig(this.config);
     this.analytics.updateConfig(this.config);
     this.signatures.updateConfig(this.config);
+    this.x402.updateConfig(this.config);
   }
   testAuthentication() {
     return testAuthentication(this.config);
   }
 };
 
-export { PinataSDK, addToGroup, analyticsDateInterval, analyticsTopUsage, convertIPFSUrl, createAccessLink, createGroup, createKey, createSignedUploadURL, deleteFile, deleteFileVectors, deleteGroup, deletePinRequest, deleteSwap, getCid, getGroup, listFiles, listGroups, listKeys, pinnedFileCount, queue, removeFromGroup, revokeKeys, swapCid, swapHistory, testAuthentication, totalStorageUsage, updateFile, updateGroup, uploadBase64, uploadCid, uploadFile, uploadFileArray, uploadJson, uploadUrl, vectorizeFile, vectorizeQuery };
+export { PinataSDK, addCid, addToGroup, analyticsDateInterval, analyticsTopUsage, convertIPFSUrl, createAccessLink, createGroup, createKey, createPaymentInstruction, createSignedUploadURL, deleteFile, deleteFileVectors, deleteGroup, deletePaymentInstruction, deletePinRequest, deleteSwap, getCid, getGroup, getPaymentInstruction, listCids, listFiles, listGroups, listKeys, listPaymentInstructions, pinnedFileCount, queue, removeCid, removeFromGroup, revokeKeys, swapCid, swapHistory, testAuthentication, totalStorageUsage, updateFile, updateGroup, updatePaymentInstruction, uploadBase64, uploadCid, uploadFile, uploadFileArray, uploadJson, uploadUrl, vectorizeFile, vectorizeQuery };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map