@plyaz/api 1.3.0 → 1.4.0

package/dist/api/services/virustotal/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/api/services/virustotal/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAGhD,OAAO,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC"}

package/dist/api/utils/aws/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * AWS Utilities
+ * Helpers for AWS API integration
+ */
+export * from './signature-v4';
+export * from './xml';
+//# sourceMappingURL=index.d.ts.map

package/dist/api/utils/aws/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/api/utils/aws/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,cAAc,gBAAgB,CAAC;AAC/B,cAAc,OAAO,CAAC"}

package/dist/api/utils/aws/signature-v4.d.ts

@@ -0,0 +1,41 @@
+/**
+ * AWS Signature Version 4 Utilities
+ * Implements AWS Signature V4 signing for API requests
+ *
+ * @see https://docs.aws.amazon.com/general/latest/gr/sigv4_signing.html
+ */
+import type { AWSSignatureV4Options, AWSSignatureV4Result } from '@plyaz/types/api';
+/**
+ * Generate AWS Signature Version 4 for request authentication
+ *
+ * @param options - Signature generation options
+ * @param options.accessKeyId - AWS access key ID
+ * @param options.secretAccessKey - AWS secret access key
+ * @param options.sessionToken - AWS session token (optional, for temporary credentials)
+ * @param options.region - AWS region (e.g., 'us-east-1')
+ * @param options.service - AWS service name (e.g., 'cloudfront', 's3')
+ * @param options.method - HTTP method (e.g., 'GET', 'POST')
+ * @param options.path - Request path
+ * @param options.queryString - Query string parameters (optional)
+ * @param options.headers - HTTP headers
+ * @param options.payload - Request payload/body
+ * @param options.host - Host header value
+ * @param options.timestamp - ISO 8601 timestamp in YYYYMMDDTHHmmssZ format (optional, auto-generated if not provided)
+ * @returns Signed headers and authorization header
+ *
+ * @example
+ * ```typescript
+ * const { headers, authorization } = generateAWSSignatureV4({
+ *   accessKeyId: 'AKIAIOSFODNN7EXAMPLE',
+ *   secretAccessKey: 'wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY',
+ *   region: 'us-east-1',
+ *   service: 'cloudfront',
+ *   method: 'POST',
+ *   path: '/2020-05-31/distribution/E1234/invalidation',
+ *   headers: { 'Host': 'cloudfront.amazonaws.com', 'Content-Type': 'application/xml' },
+ *   payload: '<xml>...</xml>',
+ * });
+ * ```
+ */
+export declare function generateAWSSignatureV4(options: AWSSignatureV4Options): AWSSignatureV4Result;
+//# sourceMappingURL=signature-v4.d.ts.map

package/dist/api/utils/aws/signature-v4.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signature-v4.d.ts","sourceRoot":"","sources":["../../../../src/api/utils/aws/signature-v4.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,qBAAqB,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAEpF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,qBAAqB,GAAG,oBAAoB,CAgF3F"}

package/dist/api/utils/aws/xml/cloudfront.d.ts

@@ -0,0 +1,37 @@
+/**
+ * AWS CloudFront XML Utilities
+ * Generates XML bodies for CloudFront API requests
+ *
+ * @see https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_CreateInvalidation.html
+ */
+/**
+ * Generate XML body for CloudFront invalidation request
+ *
+ * @param paths - List of paths to invalidate (e.g., ['/images/*', '/styles/main.css'])
+ * @param callerReference - Unique identifier for this invalidation request
+ * @returns XML string formatted for CloudFront API
+ *
+ * @example
+ * ```typescript
+ * const xml = generateCloudFrontInvalidationXML(
+ *   ['/images/*', '/styles/main.css'],
+ *   'api-1234567890'
+ * );
+ * ```
+ */
+export declare function generateCloudFrontInvalidationXML(paths: string[], callerReference: string): string;
+/**
+ * Generate unique caller reference for CloudFront invalidation
+ * Uses timestamp-based unique identifier
+ *
+ * @param prefix - Optional prefix for the caller reference (default: 'api')
+ * @returns Unique caller reference string
+ *
+ * @example
+ * ```typescript
+ * const ref = generateCloudFrontCallerReference(); // 'api-1234567890123'
+ * const customRef = generateCloudFrontCallerReference('storage'); // 'storage-1234567890123'
+ * ```
+ */
+export declare function generateCloudFrontCallerReference(prefix?: string): string;
+//# sourceMappingURL=cloudfront.d.ts.map

package/dist/api/utils/aws/xml/cloudfront.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloudfront.d.ts","sourceRoot":"","sources":["../../../../../src/api/utils/aws/xml/cloudfront.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,iCAAiC,CAC/C,KAAK,EAAE,MAAM,EAAE,EACf,eAAe,EAAE,MAAM,GACtB,MAAM,CAaR;AAiBD;;;;;;;;;;;;GAYG;AACH,wBAAgB,iCAAiC,CAAC,MAAM,SAAQ,GAAG,MAAM,CAExE"}

package/dist/api/utils/aws/xml/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * AWS XML Utilities
+ * XML generation for various AWS services
+ */
+export * from './cloudfront';
+//# sourceMappingURL=index.d.ts.map

package/dist/api/utils/aws/xml/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/api/utils/aws/xml/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,cAAc,cAAc,CAAC"}

package/dist/index.cjs

@@ -10,10 +10,30 @@ var errors = require('@plyaz/types/errors');
 var async_hooks = require('async_hooks');
 var common = require('@nestjs/common');
 var rxjs = require('rxjs');
-var crypto$1 = require('crypto');
+var crypto2 = require('crypto');
 var reactQuery = require('@tanstack/react-query');
 var react = require('react');
 
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var crypto2__namespace = /*#__PURE__*/_interopNamespace(crypto2);
+
 // @plyaz package - Built with tsup
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -613,7 +633,7 @@ function getCrypto() {
 }
 __name(getCrypto, "getCrypto");
 function generateUUID() {
-  const crypto2 = getCrypto();
+  const crypto3 = getCrypto();
   const UUID_CONSTANTS = {
     BYTES: 16,
     VERSION_POSITION: 6,
@@ -630,12 +650,12 @@ function generateUUID() {
     // eslint-disable-next-line no-magic-numbers
     POSITIONS: [8, 12, 16, 20, 32]
   };
-  if (crypto2 && typeof crypto2.randomUUID === "function") {
-    return crypto2.randomUUID();
+  if (crypto3 && typeof crypto3.randomUUID === "function") {
+    return crypto3.randomUUID();
   }
-  if (crypto2?.getRandomValues) {
+  if (crypto3?.getRandomValues) {
     const bytes = new Uint8Array(UUID_CONSTANTS.BYTES);
-    crypto2.getRandomValues(bytes);
+    crypto3.getRandomValues(bytes);
     bytes[UUID_CONSTANTS.VERSION_POSITION] = bytes[UUID_CONSTANTS.VERSION_POSITION] & UUID_CONSTANTS.VERSION_MASK | UUID_CONSTANTS.VERSION_VALUE;
     bytes[UUID_CONSTANTS.VARIANT_POSITION] = bytes[UUID_CONSTANTS.VARIANT_POSITION] & UUID_CONSTANTS.VARIANT_MASK | UUID_CONSTANTS.VARIANT_VALUE;
     const hex = Array.from(
@@ -14018,6 +14038,108 @@ var infobipEndpoints = {
   ...infobipEmailEndpoints
 };
 
+// src/api/endpoints/virustotal.ts
+var virusTotalEndpoints = {
+  // ========== File Scanning ==========
+  /**
+   * POST /files - Upload file for scanning
+   * Multipart/form-data with file attachment
+   * See official documentation for current free tier limits:
+   * https://developers.virustotal.com/reference/overview#public-vs-premium-api
+   *
+   * @returns {object} response - Upload response with analysis ID
+   * @returns {string} response.data.id - Analysis ID for polling results
+   */
+  uploadFileForScanning: {
+    url: "/files",
+    method: "POST"
+  },
+  /**
+   * GET /analyses/{id} - Get analysis result
+   * Retrieve scan results for previously uploaded file
+   *
+   * @param {string} id - Analysis ID from upload response
+   * @returns {object} response - Analysis result with threat details
+   */
+  getAnalysisResult: {
+    url: "/analyses/:id",
+    method: "GET",
+    cacheTime: 0
+    // Don't cache scan results (they update)
+  },
+  // ========== Health & Info ==========
+  /**
+   * GET /version - Get API version info (health check)
+   * Simple endpoint to verify API availability
+   */
+  getApiVersion: {
+    url: "/version",
+    method: "GET",
+    cacheTime: 300,
+    // Cache for 5 minutes
+    staleTime: 600
+  }
+};
+({
+  ...virusTotalEndpoints
+});
+var cloudflareEndpoints = {
+  /**
+   * POST /zones/{zoneId}/purge_cache - Purge files from cache
+   * Purge specific files or all files in a zone
+   * Rate limits may change; see official documentation for current limits:
+   * https://developers.cloudflare.com/api/operations/zone-purge#rate-limits
+   *
+   * @param {string} zoneId - Cloudflare Zone ID
+   * @returns {object} response - Purge result with success status
+   */
+  cloudflarePurgeCache: {
+    url: "/zones/:zoneId/purge_cache",
+    method: "POST",
+    cacheTime: 0
+    // Don't cache purge operations
+  }
+};
+var cloudFrontEndpoints = {
+  /**
+   * POST /{apiVersion}/distribution/{distributionId}/invalidation - Create invalidation
+   * Creates an invalidation batch for specified paths
+   * Rate limits may change; see the official AWS documentation for current limits:
+   * https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/cloudfront-limits.html
+   * Requires AWS Signature Version 4 authentication
+   *
+   * @param {string} distributionId - CloudFront Distribution ID
+   * @returns {object} response - Invalidation result with ID and status
+   */
+  cloudFrontCreateInvalidation: {
+    url: `/${config.AWS_CLOUDFRONT_CONFIG.API_VERSION}/distribution/:distributionId/invalidation`,
+    method: "POST",
+    cacheTime: 0
+  }
+};
+var fastlyEndpoints = {
+  /**
+   * POST /service/{serviceId}/purge/{url} - Purge single URL
+   * Instant soft-purge of specific URL
+   * Rate limit: Unlimited soft-purges. Hard-purges are limited to 1000 requests per hour per service (as of 2024-06). See Fastly documentation for updates:
+   * @see https://developer.fastly.com/reference/api/purging/#rate-limits
+   *
+   * @param {string} serviceId - Fastly Service ID
+   * @param {string} url - URL to purge (URL-encoded)
+   * @returns {object} response - Purge result with status
+   */
+  fastlyPurgeUrl: {
+    url: "/service/:serviceId/purge/:url",
+    method: "POST",
+    cacheTime: 0
+  }
+};
+var cdnEndpoints = {
+  ...cloudflareEndpoints,
+  ...cloudFrontEndpoints,
+  ...fastlyEndpoints
+};
+
 // src/api/endpoints/utils.ts
 function getEndpointUrl(name) {
   return endpoints[name].url;
@@ -14192,7 +14314,13 @@ var endpoints = {
   // These are only examples for the polling, none of these endpoints doesnt exist yet
   ...pollingEndpoints,
   // Infobip third-party provider endpoints (Email, SMS, WhatsApp)
-  ...infobipEndpoints
+  ...infobipEndpoints,
+  // VirusTotal third-party provider endpoints (Virus/Malware scanning)
+  ...virusTotalEndpoints,
+  // CDN provider endpoints (Cloudflare, CloudFront, Fastly)
+  ...cloudflareEndpoints,
+  ...cloudFrontEndpoints,
+  ...fastlyEndpoints
 };
 var isSlowConnection = fetchff.isSlowConnection;
 function isNetworkAPISupported() {
@@ -21267,7 +21395,7 @@ function getHeaderFingerprint(headers2) {
     return "no-cache-affecting-headers";
   }
   const content = parts.join("|");
-  return crypto$1.createHash("sha256").update(content).digest("hex").substring(0, FINGERPRINT_LENGTH);
+  return crypto2.createHash("sha256").update(content).digest("hex").substring(0, FINGERPRINT_LENGTH);
 }
 __name(getHeaderFingerprint, "getHeaderFingerprint");
 
@@ -25412,6 +25540,335 @@ async function updateInfobipScheduledEmailStatuses(params, payload, options) {
   });
 }
 __name(updateInfobipScheduledEmailStatuses, "updateInfobipScheduledEmailStatuses");
+async function uploadFileForScanning(payload, options) {
+  const client = options?.apiClient ?? getDefaultApiClient();
+  if (!payload.file) {
+    throw new ApiPackageError(
+      "Missing required field: file",
+      void 0,
+      api.API_ERROR_CODES.REQUIRED_FIELD_MISSING
+    );
+  }
+  if (!payload.filename) {
+    throw new ApiPackageError(
+      "Missing required field: filename",
+      void 0,
+      api.API_ERROR_CODES.REQUIRED_FIELD_MISSING
+    );
+  }
+  if (payload.file.length === 0) {
+    throw new ApiPackageError(
+      "File buffer cannot be empty",
+      void 0,
+      api.API_ERROR_CODES.INVALID_INPUT
+    );
+  }
+  const serviceDefaults = {
+    retry: { attempts: 2 },
+    // Allow retries for network issues
+    timeout: 6e4
+    // 60 second timeout for file uploads
+  };
+  const mergedConfig = mergeConfigs(serviceDefaults, options?.apiConfig ?? {});
+  const updateOptions = {
+    strategy: "temporary",
+    ...options?.updateConfigOptions
+  };
+  if (shouldApplyConfig(mergedConfig, updateOptions)) {
+    client.updateConfig(mergedConfig, updateOptions);
+  }
+  const formData = new FormData();
+  const blob = new Blob([new Uint8Array(payload.file)]);
+  formData.append("file", blob, payload.filename);
+  return client.uploadFileForScanning({
+    body: formData
+  });
+}
+__name(uploadFileForScanning, "uploadFileForScanning");
+async function getAnalysisResult(payload, options) {
+  const client = options?.apiClient ?? getDefaultApiClient();
+  if (!payload.analysisId) {
+    throw new ApiPackageError(
+      "Missing required field: analysisId",
+      void 0,
+      api.API_ERROR_CODES.REQUIRED_FIELD_MISSING
+    );
+  }
+  const serviceDefaults = {
+    retry: { attempts: 3 },
+    // Allow retries for polling
+    timeout: 3e4,
+    // 30 second timeout
+    cacheTime: 0
+    // Don't cache (results change as scan progresses)
+  };
+  const mergedConfig = mergeConfigs(serviceDefaults, options?.apiConfig ?? {});
+  const updateOptions = {
+    strategy: "temporary",
+    ...options?.updateConfigOptions
+  };
+  if (shouldApplyConfig(mergedConfig, updateOptions)) {
+    client.updateConfig(mergedConfig, updateOptions);
+  }
+  return client.getAnalysisResult({
+    params: { id: payload.analysisId }
+  });
+}
+__name(getAnalysisResult, "getAnalysisResult");
+async function cloudflarePurgeCache(payload, options) {
+  const client = options?.apiClient ?? getDefaultApiClient();
+  if (!payload.zoneId) {
+    throw new ApiPackageError(
+      "Missing required field: zoneId",
+      config.HTTP_STATUS.BAD_REQUEST,
+      api.API_ERROR_CODES.CLOUDFLARE_ZONE_NOT_FOUND
+    );
+  }
+  if (!payload.apiToken) {
+    throw new ApiPackageError(
+      "Missing required field: apiToken",
+      config.HTTP_STATUS.UNAUTHORIZED,
+      api.API_ERROR_CODES.CLOUDFLARE_AUTHENTICATION_FAILED
+    );
+  }
+  if (!payload.files || payload.files.length === 0) {
+    throw new ApiPackageError(
+      "Missing required field: files (must be non-empty array)",
+      config.HTTP_STATUS.BAD_REQUEST,
+      api.API_ERROR_CODES.CLOUDFLARE_INVALID_URL
+    );
+  }
+  const serviceDefaults = {
+    retry: { attempts: 2 },
+    timeout: 3e4
+    // 30 seconds
+  };
+  const mergedConfig = mergeConfigs(serviceDefaults, options?.apiConfig ?? {});
+  const updateOptions = {
+    strategy: "temporary",
+    ...options?.updateConfigOptions
+  };
+  if (shouldApplyConfig(mergedConfig, updateOptions)) {
+    client.updateConfig(mergedConfig, updateOptions);
+  }
+  return client.cloudflarePurgeCache({
+    params: { zoneId: payload.zoneId },
+    headers: {
+      Authorization: `Bearer ${payload.apiToken}`
+    },
+    body: {
+      files: payload.files,
+      zoneId: payload.zoneId,
+      apiToken: payload.apiToken
+    }
+  });
+}
+__name(cloudflarePurgeCache, "cloudflarePurgeCache");
+function generateAWSSignatureV4(options) {
+  const {
+    accessKeyId,
+    secretAccessKey,
+    sessionToken,
+    region,
+    service,
+    method,
+    path,
+    queryString = "",
+    headers: headers2,
+    payload,
+    host
+  } = options;
+  const timestamp = options.timestamp ?? (/* @__PURE__ */ new Date()).toISOString().replace(/[:-]|\.\d{3}/g, "");
+  const dateStamp = timestamp.split("T")[0];
+  const baseHeaders = { ...headers2 };
+  if (!Object.keys(baseHeaders).some((h) => h.toLowerCase() === "host")) {
+    baseHeaders["Host"] = host;
+  }
+  if (sessionToken) {
+    baseHeaders["X-Amz-Security-Token"] = sessionToken;
+  }
+  baseHeaders["X-Amz-Date"] = timestamp;
+  const canonicalHeaders = Object.keys(baseHeaders).sort().map((key) => `${key.toLowerCase()}:${baseHeaders[key].trim()}`).join("\n");
+  const signedHeaders = Object.keys(baseHeaders).sort().map((key) => key.toLowerCase()).join(";");
+  const payloadHash = crypto2__namespace.createHash("sha256").update(payload).digest("hex");
+  const canonicalRequest = [
+    method,
+    path,
+    queryString,
+    canonicalHeaders + "\n",
+    signedHeaders,
+    payloadHash
+  ].join("\n");
+  const algorithm = "AWS4-HMAC-SHA256";
+  const credentialScope = `${dateStamp}/${region}/${service}/aws4_request`;
+  const canonicalRequestHash = crypto2__namespace.createHash("sha256").update(canonicalRequest).digest("hex");
+  const stringToSign = [algorithm, timestamp, credentialScope, canonicalRequestHash].join("\n");
+  const kDate = crypto2__namespace.createHmac("sha256", `AWS4${secretAccessKey}`).update(dateStamp).digest();
+  const kRegion = crypto2__namespace.createHmac("sha256", kDate).update(region).digest();
+  const kService = crypto2__namespace.createHmac("sha256", kRegion).update(service).digest();
+  const kSigning = crypto2__namespace.createHmac("sha256", kService).update("aws4_request").digest();
+  const signature = crypto2__namespace.createHmac("sha256", kSigning).update(stringToSign).digest("hex");
+  const authorization = `${algorithm} Credential=${accessKeyId}/${credentialScope}, SignedHeaders=${signedHeaders}, Signature=${signature}`;
+  return {
+    headers: baseHeaders,
+    authorization
+  };
+}
+__name(generateAWSSignatureV4, "generateAWSSignatureV4");
+
+// src/api/utils/aws/xml/cloudfront.ts
+function generateCloudFrontInvalidationXML(paths, callerReference) {
+  const items = paths.map((path) => `<Path>${escapeXml(path)}</Path>`).join("\n    ");
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<InvalidationBatch xmlns="http://cloudfront.amazonaws.com/doc/2020-05-31/">
+  <Paths>
+    <Quantity>${paths.length}</Quantity>
+    <Items>
+    ${items}
+    </Items>
+  </Paths>
+  <CallerReference>${escapeXml(callerReference)}</CallerReference>
+</InvalidationBatch>`;
+}
+__name(generateCloudFrontInvalidationXML, "generateCloudFrontInvalidationXML");
+function escapeXml(str) {
+  const xmlEscapes = {
+    "&": "&amp;",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;",
+    "'": "&apos;"
+  };
+  return str.replace(/[&<>"']/g, (ch) => xmlEscapes[ch]);
+}
+__name(escapeXml, "escapeXml");
+function generateCloudFrontCallerReference(prefix = "api") {
+  return `${prefix}-${Date.now()}`;
+}
+__name(generateCloudFrontCallerReference, "generateCloudFrontCallerReference");
+
+// src/api/services/cdn/cloudfront/POST/cloudFrontCreateInvalidation.ts
+async function cloudFrontCreateInvalidation(payload, options) {
+  const client = options?.apiClient ?? getDefaultApiClient();
+  if (!payload.distributionId) {
+    throw new ApiPackageError(
+      "Missing required field: distributionId",
+      config.HTTP_STATUS.BAD_REQUEST,
+      api.API_ERROR_CODES.CLOUDFRONT_DISTRIBUTION_NOT_FOUND
+    );
+  }
+  if (!payload.accessKeyId) {
+    throw new ApiPackageError(
+      "Missing required field: accessKeyId",
+      config.HTTP_STATUS.UNAUTHORIZED,
+      api.API_ERROR_CODES.CLOUDFRONT_AUTHENTICATION_FAILED
+    );
+  }
+  if (!payload.secretAccessKey) {
+    throw new ApiPackageError(
+      "Missing required field: secretAccessKey",
+      config.HTTP_STATUS.UNAUTHORIZED,
+      api.API_ERROR_CODES.CLOUDFRONT_AUTHENTICATION_FAILED
+    );
+  }
+  if (!payload.paths || payload.paths.length === 0) {
+    throw new ApiPackageError(
+      "Missing required field: paths (must be non-empty array)",
+      config.HTTP_STATUS.BAD_REQUEST,
+      api.API_ERROR_CODES.CLOUDFRONT_INVALID_PATH
+    );
+  }
+  const region = payload.region ?? config.AWS_CLOUDFRONT_CONFIG.DEFAULT_REGION;
+  const service = config.AWS_CLOUDFRONT_CONFIG.SERVICE_NAME;
+  const host = config.AWS_CLOUDFRONT_CONFIG.HOST;
+  const method = "POST";
+  const path = `/${config.AWS_CLOUDFRONT_CONFIG.API_VERSION}/distribution/${payload.distributionId}/invalidation`;
+  const callerReference = generateCloudFrontCallerReference("api");
+  const body = generateCloudFrontInvalidationXML(payload.paths, callerReference);
+  const { headers: signedHeaders, authorization } = generateAWSSignatureV4({
+    accessKeyId: payload.accessKeyId,
+    secretAccessKey: payload.secretAccessKey,
+    sessionToken: payload.sessionToken,
+    region,
+    service,
+    method,
+    path,
+    host,
+    headers: {
+      "Content-Type": "application/xml"
+    },
+    payload: body
+  });
+  const serviceDefaults = {
+    retry: { attempts: 2 },
+    timeout: 3e4
+    // 30 seconds
+  };
+  const mergedConfig = mergeConfigs(serviceDefaults, options?.apiConfig ?? {});
+  const updateOptions = {
+    strategy: "temporary",
+    ...options?.updateConfigOptions
+  };
+  if (shouldApplyConfig(mergedConfig, updateOptions)) {
+    client.updateConfig(mergedConfig, updateOptions);
+  }
+  return client.cloudFrontCreateInvalidation({
+    params: { distributionId: payload.distributionId },
+    headers: {
+      ...signedHeaders,
+      Authorization: authorization
+    },
+    body
+  });
+}
+__name(cloudFrontCreateInvalidation, "cloudFrontCreateInvalidation");
+async function fastlyPurgeUrl(payload, options) {
+  const client = options?.apiClient ?? getDefaultApiClient();
+  if (!payload.serviceId) {
+    throw new ApiPackageError(
+      "Missing required field: serviceId",
+      config.HTTP_STATUS.BAD_REQUEST,
+      api.API_ERROR_CODES.FASTLY_SERVICE_NOT_FOUND
+    );
+  }
+  if (!payload.apiToken) {
+    throw new ApiPackageError(
+      "Missing required field: apiToken",
+      config.HTTP_STATUS.UNAUTHORIZED,
+      api.API_ERROR_CODES.FASTLY_AUTHENTICATION_FAILED
+    );
+  }
+  if (!payload.url) {
+    throw new ApiPackageError(
+      "Missing required field: url",
+      config.HTTP_STATUS.BAD_REQUEST,
+      api.API_ERROR_CODES.FASTLY_INVALID_URL
+    );
+  }
+  const serviceDefaults = {
+    retry: { attempts: 2 },
+    timeout: 15e3
+    // 15 seconds
+  };
+  const mergedConfig = mergeConfigs(serviceDefaults, options?.apiConfig ?? {});
+  const updateOptions = {
+    strategy: "temporary",
+    ...options?.updateConfigOptions
+  };
+  if (shouldApplyConfig(mergedConfig, updateOptions)) {
+    client.updateConfig(mergedConfig, updateOptions);
+  }
+  return client.fastlyPurgeUrl({
+    params: {
+      serviceId: payload.serviceId,
+      url: encodeURIComponent(payload.url)
+    },
+    headers: {
+      "Fastly-Key": payload.apiToken
+    }
+  });
+}
+__name(fastlyPurgeUrl, "fastlyPurgeUrl");
 function getSSRSafeConfig(config) {
   if (!isBrowser()) {
     return {
@@ -25757,6 +26214,7 @@ exports.calculatePollingDuration = calculatePollingDuration;
 exports.calculateRequestMetrics = calculateRequestMetrics;
 exports.campaignEndpoints = campaignEndpoints;
 exports.canPerformHeavyOperation = canPerformHeavyOperation;
+exports.cdnEndpoints = cdnEndpoints;
 exports.checkOverrideTriggers = checkOverrideTriggers;
 exports.clamp = clamp;
 exports.clampedPercentage = clampedPercentage;
@@ -25764,6 +26222,10 @@ exports.clearErrorHandlers = clearErrorHandlers;
 exports.clearNetworkDebugData = clearNetworkDebugData;
 exports.clearTemporaryOverrides = clearTemporaryOverrides;
 exports.cloneConfig = cloneConfig;
+exports.cloudFrontCreateInvalidation = cloudFrontCreateInvalidation;
+exports.cloudFrontEndpoints = cloudFrontEndpoints;
+exports.cloudflareEndpoints = cloudflareEndpoints;
+exports.cloudflarePurgeCache = cloudflarePurgeCache;
 exports.compactHistory = compactHistory;
 exports.configConflictDetector = configConflictDetector;
 exports.configureForEnvironment = configureForEnvironment;
@@ -25836,6 +26298,8 @@ exports.exportKeyToBase64 = exportKeyToBase64;
 exports.extendRevalidationPresets = extendPresets;
 exports.extractFields = extractFields;
 exports.extractUrlParams = extractUrlParams;
+exports.fastlyEndpoints = fastlyEndpoints;
+exports.fastlyPurgeUrl = fastlyPurgeUrl;
 exports.fetchCampaign = fetchCampaign;
 exports.fetchCampaignParticipants = fetchCampaignParticipants;
 exports.fetchCampaignStats = fetchCampaignStats;
@@ -25872,6 +26336,7 @@ exports.getAdaptiveTimeout = getAdaptiveTimeout;
 exports.getAllEndpointUrls = getAllEndpointUrls;
 exports.getAllFieldPaths = getAllFieldPaths;
 exports.getAllMediaExtensions = getAllMediaExtensions;
+exports.getAnalysisResult = getAnalysisResult;
 exports.getAppVersion = getAppVersion;
 exports.getAuthenticationType = getAuthenticationType;
 exports.getCache = getCache;
@@ -26195,6 +26660,7 @@ exports.unregisterErrorHandlers = unregisterErrorHandlers;
 exports.updateCampaign = updateCampaign;
 exports.updateGlobalConfig = updateGlobalConfig;
 exports.updateInfobipScheduledEmailStatuses = updateInfobipScheduledEmailStatuses;
+exports.uploadFileForScanning = uploadFileForScanning;
 exports.useAbortableRequest = useAbortableRequest;
 exports.useApiConfigConflicts = useApiConfigConflicts;
 exports.useApiDebugInfo = useApiDebugInfo;
@@ -26225,6 +26691,7 @@ exports.validateHeaders = validateHeaders2;
 exports.validateInfobipEmail = validateInfobipEmail;
 exports.validatePathParams = validatePathParams;
 exports.validatePreset = validatePreset;
+exports.virusTotalEndpoints = virusTotalEndpoints;
 exports.waitForOnline = waitForOnline;
 exports.withNetworkDetection = withNetworkDetection;
 exports.withNetworkInfo = withNetworkInfo;