@plyaz/api 1.6.7 → 1.7.0

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { ApiPackageError as ApiPackageError$1, emitScopedErrorEvent, generateCorrelationId, generateRequestId, generateTraceCorrelationId, registerEventFactory, registerErrorHandler as registerErrorHandler$1, registerScopedHandlers, setErrorHandlers as setErrorHandlers$1, getErrorHandlers as getErrorHandlers$1, unregisterScopedHandlers, clearErrorHandlers as clearErrorHandlers$1, registerOnceErrorHandler, isErrorSystemInitialized, setErrorLocale, addMessageCatalog, initializeErrorSystem } from '@plyaz/errors';
+import { ApiPackageError as ApiPackageError$1, emitScopedErrorEvent, generateCorrelationId, generateRequestId, generateTraceCorrelationId, registerEventFactory, registerErrorHandler as registerErrorHandler$1, registerScopedHandlers, setErrorHandlers as setErrorHandlers$1, getErrorHandlers as getErrorHandlers$1, unregisterScopedHandlers, clearErrorHandlers as clearErrorHandlers$1, registerOnceErrorHandler, isErrorSystemInitialized, setErrorLocale, addMessageCatalog, initializeErrorSystem, getErrorCodeByStatus } from '@plyaz/errors';
 export { getErrorCategory, getErrorCodeByStatus, getErrorDefinition } from '@plyaz/errors';
 import { abortRequest as abortRequest$1, isSlowConnection as isSlowConnection$1, deleteCache as deleteCache$1, getCache as getCache$1, mutate, setCache as setCache$1, subscribe as subscribe$1, revalidateAll as revalidateAll$1, revalidate, setDefaultConfig, createApiFetcher } from 'fetchff';
 export { removeRevalidators, revalidate, revalidateAll } from 'fetchff';
@@ -6,7 +6,7 @@ import { PRIORITY_LEVEL, EVENT_SCOPES_WITH_TEMPORARY, EVENT_NAMESPACES, HEADER_E
 export { NETWORK_QUALITY, PUB_SUB_EVENT } from '@plyaz/types/api';
 import { ApiLogger } from '@plyaz/logger';
 import { LOGGER_SERVICES } from '@plyaz/types';
-import { isDev, HTTP_STATUS, TIME_CONSTANTS, AWS_CLOUDFRONT_CONFIG, NUMERIC_CONSTANTS, MULTIPLIERS, NETWORK_SCORES, NETWORK_TIMEOUTS, RETRY_BACKOFF, RETRY_DELAYS, RETRY_ATTEMPTS, DEDUPE_TIME, CACHE_STALE, CACHE_TTL, BATCH_SIZES, PAGE_SIZES, TIMEZONE_REGIONS, LOCALE_REGIONS_DETAILED, COUNTRY_REGIONS_DETAILED, DEFAULT_API_CONFIG, DEFAULT_API_CLIENT_OPTIONS } from '@plyaz/config';
+import { isDev, HTTP_STATUS, TIME_CONSTANTS, AWS_CLOUDFRONT_CONFIG, NUMERIC_CONSTANTS, MULTIPLIERS, MATH_CONSTANTS as MATH_CONSTANTS$1, RETRY_DELAYS, RETRY_BACKOFF, NUMBER_SYSTEM, NETWORK_SCORES, NETWORK_TIMEOUTS, RETRY_ATTEMPTS, DEDUPE_TIME, CACHE_STALE, CACHE_TTL, BATCH_SIZES, PAGE_SIZES, TIMEZONE_REGIONS, LOCALE_REGIONS_DETAILED, COUNTRY_REGIONS_DETAILED, DEFAULT_API_CONFIG, DEFAULT_API_CLIENT_OPTIONS } from '@plyaz/config';
 import 'events';
 import { INTERNAL_STATUS_CODES, API_ERROR_CODES as API_ERROR_CODES$1, COMMON_OPERATIONS } from '@plyaz/types/errors';
 export { API_ERROR_CODES, ERROR_DEFINITIONS, COMMON_FIELDS as ERROR_FIELDS, COMMON_OPERATIONS as OPERATIONS, COMMON_STORAGE_TYPES as STORAGE_TYPES } from '@plyaz/types/errors';
@@ -9132,6 +9132,9 @@ var UnifiedDebugger = class _UnifiedDebugger {
   performanceMode = "minimal";
   trackAllProperties = true;
   // If false, uses TRACKED_PROPERTIES filter
+  // Debug report control - disabled by default, enable via config:
+  // createApiClient({ debugEvents: { comprehensiveReport: true } })
+  comprehensiveReportEnabled = false;
   // Tracking configuration from API config
   trackingConfig = {};
   // Configurable limits
@@ -9560,8 +9563,14 @@ var UnifiedDebugger = class _UnifiedDebugger {
   }
   /**
    * Log comprehensive report to console
+   *
+   * Controlled via API config: debugEvents.comprehensiveReport = true
+   * Or programmatically via setComprehensiveReportEnabled(true)
    */
   async logComprehensiveReport() {
+    if (!this.comprehensiveReportEnabled) {
+      return;
+    }
     try {
       const presetReport = this.getPresetChangeReport();
       if (presetReport) {
@@ -9583,6 +9592,20 @@ var UnifiedDebugger = class _UnifiedDebugger {
       throw error;
     }
   }
+  /**
+   * Enable or disable comprehensive debug report logging
+   *
+   * Typically configured via API config: debugEvents.comprehensiveReport
+   */
+  setComprehensiveReportEnabled(enabled) {
+    this.comprehensiveReportEnabled = enabled;
+  }
+  /**
+   * Get current comprehensive report enabled state
+   */
+  getComprehensiveReportEnabled() {
+    return this.comprehensiveReportEnabled;
+  }
   /**
    * Get debug report (alias for generateDebugReport for API consistency)
    */
@@ -16158,6 +16181,11 @@ var ClientEventManager = class _ClientEventManager {
       this.config.configOverride.eventScopes ??= [...EVENT_SCOPES$1];
     }
     eventManager.setEventScopes(this.config.configOverride.eventScopes);
+    if (this.config.debugEvents?.comprehensiveReport !== void 0) {
+      getUnifiedDebugger().setComprehensiveReportEnabled(
+        this.config.debugEvents.comprehensiveReport
+      );
+    }
     this.setupEventHandlers();
   }
   static {
@@ -16815,6 +16843,9 @@ var ClientEventManager = class _ClientEventManager {
       const id = setInterval(() => this.getDebugInfo(), interval);
       this.monitoringState.intervals.push(id);
     }
+    if (debugConfig?.comprehensiveReport !== void 0) {
+      getUnifiedDebugger().setComprehensiveReportEnabled(debugConfig.comprehensiveReport);
+    }
   }
   /**
    * Stop monitoring
@@ -21607,7 +21638,7 @@ function createOnErrorHandler(handlers, clearTemporaryOverrides2, clearOnComplet
     const apiError = new ApiPackageError(
       "request.failed",
       PACKAGE_STATUS_CODES.REQUEST_FAILED,
-      error.status ? `HTTP_${error.status}` : API_ERROR_CODES.NETWORK_ERROR,
+      error.status ? getErrorCodeByStatus(error.status) ?? API_ERROR_CODES.CLIENT_ERROR : API_ERROR_CODES.NETWORK_ERROR,
       {
         cause: error,
         context: {
@@ -22233,6 +22264,546 @@ function applyQualityBasedConfiguration(resolvedConfig, quality, networkAware, n
   }
 }
 __name(applyQualityBasedConfiguration, "applyQualityBasedConfiguration");
+var PROGRESS_CHUNK_SIZE_MULTIPLIER = 64;
+var UPLOAD_CONSTANTS = {
+  DEFAULT_CHUNK_SIZE: PROGRESS_CHUNK_SIZE_MULTIPLIER * NUMBER_SYSTEM.BYTES_PER_KB,
+  DEFAULT_THROTTLE_MS: TIME_CONSTANTS.HUNDRED_MS,
+  DEFAULT_CONTENT_TYPE: "application/octet-stream",
+  DEFAULT_TIMEOUT: TIME_CONSTANTS.TWO_MINUTES,
+  DEFAULT_RETRY_DELAY: RETRY_DELAYS.SHORT,
+  DEFAULT_RETRY_BACKOFF: RETRY_BACKOFF.MEDIUM,
+  DEFAULT_RETRY_MAX_DELAY: RETRY_DELAYS.MAX,
+  PROGRESS_PERCENTAGE_THRESHOLD: NUMERIC_CONSTANTS.FIVE,
+  FULL_PERCENTAGE: MATH_CONSTANTS$1.PERCENTAGE_MAX,
+  HTTPS_DEFAULT_PORT: TIME_CONSTANTS.HTTPS_PORT,
+  HTTP_DEFAULT_PORT: TIME_CONSTANTS.HTTP_PORT,
+  /** Max server error status code (exclusive boundary for 5xx range) */
+  MAX_SERVER_ERROR_STATUS: 600
+};
+var RETRYABLE_ERROR_CODES = [
+  "ETIMEDOUT",
+  "ECONNRESET",
+  "ECONNREFUSED",
+  "ENOTFOUND",
+  "ENETUNREACH",
+  "EAI_AGAIN"
+];
+var RETRYABLE_MESSAGE_PATTERNS = [
+  "timeout",
+  "timed out",
+  "network",
+  "econnreset",
+  "econnrefused",
+  "etimedout",
+  "service unavailable",
+  "rate limit",
+  "too many requests"
+];
+
+// src/api/upload/config.ts
+function extractGlobalHeaders(globalConfig) {
+  const globalHeaders = {};
+  if (!globalConfig.headers || typeof globalConfig.headers !== "object") {
+    return globalHeaders;
+  }
+  if (!("presets" in globalConfig.headers) && !("static" in globalConfig.headers)) {
+    Object.entries(globalConfig.headers).forEach(([key, value]) => {
+      if (typeof value === "string") {
+        globalHeaders[key] = value;
+      }
+    });
+    return globalHeaders;
+  }
+  if ("static" in globalConfig.headers) {
+    const staticHeaders = globalConfig.headers.static;
+    if (staticHeaders) {
+      Object.entries(staticHeaders).forEach(([key, value]) => {
+        if (typeof value === "string") {
+          globalHeaders[key] = value;
+        }
+      });
+    }
+  }
+  return globalHeaders;
+}
+__name(extractGlobalHeaders, "extractGlobalHeaders");
+function mergeRetryConfig(optionRetry, globalRetry) {
+  if (optionRetry !== void 0) return optionRetry;
+  if (globalRetry !== void 0) return globalRetry;
+  return false;
+}
+__name(mergeRetryConfig, "mergeRetryConfig");
+function buildLocalConfig(options) {
+  return {
+    headers: options.headers ?? {},
+    timeout: options.timeout ?? UPLOAD_CONSTANTS.DEFAULT_TIMEOUT,
+    baseURL: options.baseURL,
+    retry: options.retry ?? false,
+    onError: options.onError,
+    withCredentials: options.withCredentials ?? false
+  };
+}
+__name(buildLocalConfig, "buildLocalConfig");
+function getMergedConfig(options) {
+  if (options.useGlobalConfig === false) {
+    return buildLocalConfig(options);
+  }
+  const globalConfig = getGlobalConfig();
+  const globalHeaders = extractGlobalHeaders(globalConfig);
+  return {
+    headers: { ...globalHeaders, ...options.headers ?? {} },
+    timeout: options.timeout ?? globalConfig.timeout ?? UPLOAD_CONSTANTS.DEFAULT_TIMEOUT,
+    baseURL: options.baseURL ?? globalConfig.baseURL,
+    retry: mergeRetryConfig(options.retry, globalConfig.retry),
+    onError: options.onError,
+    withCredentials: options.withCredentials ?? globalConfig.withCredentials ?? false
+  };
+}
+__name(getMergedConfig, "getMergedConfig");
+function checkRetryableFlag(error) {
+  if (typeof error.isRetryable === "function") return error.isRetryable();
+  if (typeof error.isRetryable === "boolean") return error.isRetryable;
+  if (typeof error.retryable === "boolean") return error.retryable;
+  return void 0;
+}
+__name(checkRetryableFlag, "checkRetryableFlag");
+function isRetryableStatus(status) {
+  if (status === void 0) return false;
+  if (status === HTTP_STATUS.TOO_MANY_REQUESTS) return true;
+  return status >= HTTP_STATUS.INTERNAL_SERVER_ERROR && status < UPLOAD_CONSTANTS.MAX_SERVER_ERROR_STATUS;
+}
+__name(isRetryableStatus, "isRetryableStatus");
+function hasRetryableErrorCode(error) {
+  return Boolean(
+    error.code && RETRYABLE_ERROR_CODES.includes(error.code)
+  );
+}
+__name(hasRetryableErrorCode, "hasRetryableErrorCode");
+function hasRetryableMessage(error) {
+  const message = error.message?.toLowerCase() ?? "";
+  return RETRYABLE_MESSAGE_PATTERNS.some((pattern) => message.includes(pattern));
+}
+__name(hasRetryableMessage, "hasRetryableMessage");
+function isRetryableError(error, status) {
+  if (!error) return false;
+  const errorWithRetryable = error;
+  const flagResult = checkRetryableFlag(errorWithRetryable);
+  if (flagResult !== void 0) return flagResult;
+  if (hasRetryableErrorCode(errorWithRetryable)) return true;
+  if (hasRetryableMessage(error)) return true;
+  const httpStatus = status ?? errorWithRetryable.statusCode;
+  return isRetryableStatus(httpStatus);
+}
+__name(isRetryableError, "isRetryableError");
+function calculateRetryDelay(attempt, config) {
+  const delay = config.delay ?? UPLOAD_CONSTANTS.DEFAULT_RETRY_DELAY;
+  const backoff = config.backoff ?? UPLOAD_CONSTANTS.DEFAULT_RETRY_BACKOFF;
+  const maxDelay = config.maxDelay ?? UPLOAD_CONSTANTS.DEFAULT_RETRY_MAX_DELAY;
+  const calculatedDelay = delay * Math.pow(backoff, attempt);
+  return Math.min(calculatedDelay, maxDelay);
+}
+__name(calculateRetryDelay, "calculateRetryDelay");
+function notifyRetryError(params) {
+  const { ctx, message, status, statusText, cause } = params;
+  if (!ctx.config.onError) return;
+  ctx.config.onError({
+    message,
+    status,
+    statusText,
+    cause,
+    retryable: true,
+    attempt: ctx.attempt,
+    maxAttempts: ctx.maxAttempts
+  });
+}
+__name(notifyRetryError, "notifyRetryError");
+function notifyFinalError(ctx, error) {
+  if (!ctx.config.onError) return;
+  ctx.config.onError({
+    message: error.message,
+    cause: error,
+    retryable: false,
+    attempt: ctx.attempt,
+    maxAttempts: ctx.maxAttempts
+  });
+}
+__name(notifyFinalError, "notifyFinalError");
+function shouldRetryResult(result, config, attempt, maxAttempts) {
+  if (result.success) return false;
+  if (!config.retry) return false;
+  if (attempt >= maxAttempts - 1) return false;
+  return isRetryableError(new Error(result.statusText ?? "Upload failed"), result.status);
+}
+__name(shouldRetryResult, "shouldRetryResult");
+function shouldRetryError(error, config, attempt, maxAttempts) {
+  if (!config.retry) return false;
+  if (attempt >= maxAttempts - 1) return false;
+  return isRetryableError(error);
+}
+__name(shouldRetryError, "shouldRetryError");
+async function handleRetryDelay(attempt, config) {
+  await sleep(calculateRetryDelay(attempt, config));
+}
+__name(handleRetryDelay, "handleRetryDelay");
+function resolveUrl(url, baseURL) {
+  if (url.startsWith("http://") || url.startsWith("https://")) {
+    return url;
+  }
+  if (!baseURL) {
+    return url;
+  }
+  const base = baseURL.replace(/\/$/, "");
+  const path = url.startsWith("/") ? url : `/${url}`;
+  return `${base}${path}`;
+}
+__name(resolveUrl, "resolveUrl");
+function normalizeData(data) {
+  if (Buffer.isBuffer(data)) return data;
+  if (data instanceof Uint8Array) return data;
+  if (data instanceof ArrayBuffer) return new Uint8Array(data);
+  throw new ApiPackageError(
+    "Blob data type is only supported in browser environment",
+    void 0,
+    API_ERROR_CODES$1.VALIDATION_ERROR
+  );
+}
+__name(normalizeData, "normalizeData");
+function createUploadState(totalSize) {
+  const now2 = Date.now();
+  return {
+    status: "uploading",
+    startTime: now2,
+    bytesUploaded: 0,
+    totalBytes: totalSize,
+    lastProgressTime: now2,
+    lastBytesUploaded: 0
+  };
+}
+__name(createUploadState, "createUploadState");
+function calculateProgress(state) {
+  const now2 = Date.now();
+  const timeDelta = (now2 - state.lastProgressTime) / TIME_CONSTANTS.SECOND;
+  const bytesDelta = state.bytesUploaded - state.lastBytesUploaded;
+  const speed = timeDelta > 0 ? bytesDelta / timeDelta : 0;
+  const percentage2 = Math.round(
+    state.bytesUploaded / state.totalBytes * UPLOAD_CONSTANTS.FULL_PERCENTAGE
+  );
+  const remainingBytes = state.totalBytes - state.bytesUploaded;
+  return {
+    loaded: state.bytesUploaded,
+    total: state.totalBytes,
+    percentage: percentage2,
+    speed: speed > 0 ? speed : void 0,
+    estimatedTimeRemaining: speed > 0 ? remainingBytes / speed : void 0
+  };
+}
+__name(calculateProgress, "calculateProgress");
+function emitFinalProgress(onProgress, totalSize, startTime) {
+  if (!onProgress) return;
+  const elapsed = (Date.now() - startTime) / TIME_CONSTANTS.SECOND;
+  onProgress({
+    loaded: totalSize,
+    total: totalSize,
+    percentage: UPLOAD_CONSTANTS.FULL_PERCENTAGE,
+    speed: elapsed > 0 ? totalSize / elapsed : void 0,
+    estimatedTimeRemaining: 0
+  });
+}
+__name(emitFinalProgress, "emitFinalProgress");
+function shouldEmitProgress(state, totalSize, throttleMs) {
+  const now2 = Date.now();
+  const timeSinceLastProgress = now2 - state.lastProgressTime;
+  const currentPct = Math.round(
+    state.bytesUploaded / totalSize * UPLOAD_CONSTANTS.FULL_PERCENTAGE
+  );
+  const lastPct = Math.round(
+    state.lastBytesUploaded / totalSize * UPLOAD_CONSTANTS.FULL_PERCENTAGE
+  );
+  return timeSinceLastProgress >= throttleMs || currentPct - lastPct >= UPLOAD_CONSTANTS.PROGRESS_PERCENTAGE_THRESHOLD;
+}
+__name(shouldEmitProgress, "shouldEmitProgress");
+function parseNodeHeaders(headers2) {
+  const result = {};
+  for (const [key, value] of Object.entries(headers2)) {
+    if (value !== void 0) {
+      result[key] = Array.isArray(value) ? value.join(", ") : value;
+    }
+  }
+  return result;
+}
+__name(parseNodeHeaders, "parseNodeHeaders");
+
+// src/api/upload/node.ts
+var createTimeoutError = /* @__PURE__ */ __name((url) => new ApiPackageError("Upload timed out", void 0, API_ERROR_CODES$1.REQUEST_TIMEOUT, {
+  context: { url }
+}), "createTimeoutError");
+var createAbortError = /* @__PURE__ */ __name((url) => new ApiPackageError("Upload aborted", void 0, API_ERROR_CODES$1.REQUEST_ABORTED, {
+  context: { url }
+}), "createAbortError");
+var normalizeError = /* @__PURE__ */ __name((error) => error instanceof Error ? error : new ApiPackageError(String(error), void 0, API_ERROR_CODES$1.UNKNOWN_ERROR), "normalizeError");
+async function uploadOnce(options, config, resolvedUrl) {
+  const {
+    data,
+    method = "PUT",
+    contentType = UPLOAD_CONSTANTS.DEFAULT_CONTENT_TYPE,
+    onProgress,
+    abortSignal
+  } = options;
+  const chunkSize = options.chunkSize ?? UPLOAD_CONSTANTS.DEFAULT_CHUNK_SIZE;
+  const throttleMs = options.throttleMs ?? UPLOAD_CONSTANTS.DEFAULT_THROTTLE_MS;
+  const { headers: mergedHeaders, timeout } = config;
+  const buffer = normalizeData(data);
+  const totalSize = buffer.length;
+  const parsedUrl = new URL(resolvedUrl);
+  const isHttps = parsedUrl.protocol === "https:";
+  const httpModule = await (isHttps ? import('https') : import('http'));
+  const state = createUploadState(totalSize);
+  return new Promise((resolve, reject) => {
+    let timeoutId;
+    if (timeout > 0) timeoutId = setTimeout(() => reject(createTimeoutError(resolvedUrl)), timeout);
+    const clearUploadTimeout = /* @__PURE__ */ __name(() => {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+        timeoutId = void 0;
+      }
+    }, "clearUploadTimeout");
+    onProgress?.({ loaded: 0, total: totalSize, percentage: 0 });
+    const requestOptions = {
+      hostname: parsedUrl.hostname,
+      port: parsedUrl.port || (isHttps ? UPLOAD_CONSTANTS.HTTPS_DEFAULT_PORT : UPLOAD_CONSTANTS.HTTP_DEFAULT_PORT),
+      path: parsedUrl.pathname + parsedUrl.search,
+      method,
+      headers: {
+        "Content-Type": contentType,
+        "Content-Length": totalSize.toString(),
+        ...mergedHeaders
+      }
+    };
+    const req = httpModule.request(requestOptions, (res) => {
+      let responseData = "";
+      res.on("data", (chunk) => {
+        responseData += chunk;
+      });
+      res.on("end", () => {
+        clearUploadTimeout();
+        const success = res.statusCode !== void 0 && res.statusCode >= HTTP_STATUS.OK && res.statusCode < HTTP_STATUS.MULTIPLE_CHOICES;
+        if (success) emitFinalProgress(onProgress, totalSize, state.startTime);
+        resolve({
+          status: res.statusCode ?? 0,
+          statusText: res.statusMessage ?? "",
+          data: responseData || void 0,
+          headers: parseNodeHeaders(res.headers),
+          success
+        });
+      });
+    });
+    if (abortSignal)
+      abortSignal.addEventListener("abort", () => {
+        clearUploadTimeout();
+        req.destroy();
+        state.status = "aborted";
+        reject(createAbortError(resolvedUrl));
+      });
+    req.on("error", (error) => {
+      clearUploadTimeout();
+      state.status = "failed";
+      state.error = error;
+      reject(error);
+    });
+    let offset = 0;
+    const writeNextChunk = /* @__PURE__ */ __name(() => {
+      while (offset < totalSize) {
+        const end = Math.min(offset + chunkSize, totalSize);
+        const canContinue = req.write(buffer.subarray(offset, end));
+        state.bytesUploaded = end;
+        offset = end;
+        if (onProgress && shouldEmitProgress(state, totalSize, throttleMs)) {
+          onProgress(calculateProgress(state));
+          state.lastProgressTime = Date.now();
+          state.lastBytesUploaded = state.bytesUploaded;
+        }
+        if (!canContinue) {
+          req.once("drain", writeNextChunk);
+          return;
+        }
+      }
+      state.status = "completed";
+      req.end();
+    }, "writeNextChunk");
+    writeNextChunk();
+  });
+}
+__name(uploadOnce, "uploadOnce");
+async function uploadWithProgressNode(options) {
+  const config = getMergedConfig(options);
+  const resolvedUrl = resolveUrl(options.url, config.baseURL);
+  const maxAttempts = config.retry ? (config.retry.attempts ?? 0) + 1 : 1;
+  let lastError;
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    const ctx = { config, maxAttempts, attempt };
+    try {
+      const result = await uploadOnce(options, config, resolvedUrl);
+      if (shouldRetryResult(result, config, attempt, maxAttempts)) {
+        notifyRetryError({
+          ctx,
+          message: `Upload failed: ${result.status}`,
+          status: result.status,
+          statusText: result.statusText
+        });
+        await handleRetryDelay(attempt, config.retry);
+        continue;
+      }
+      return { ...result, attempts: attempt };
+    } catch (error) {
+      lastError = normalizeError(error);
+      if (shouldRetryError(lastError, config, attempt, maxAttempts)) {
+        notifyRetryError({ ctx, message: lastError.message, cause: lastError });
+        await handleRetryDelay(attempt, config.retry);
+        continue;
+      }
+      notifyFinalError(ctx, lastError);
+      throw lastError;
+    }
+  }
+  throw lastError ?? new ApiPackageError(
+    "Upload failed after all retry attempts",
+    void 0,
+    API_ERROR_CODES$1.NETWORK_ERROR
+  );
+}
+__name(uploadWithProgressNode, "uploadWithProgressNode");
+var normalizeError2 = /* @__PURE__ */ __name((error) => error instanceof Error ? error : new ApiPackageError(String(error), void 0, API_ERROR_CODES$1.UNKNOWN_ERROR), "normalizeError");
+async function uploadOnce2(options, config, resolvedUrl) {
+  const {
+    data,
+    method = "PUT",
+    contentType = UPLOAD_CONSTANTS.DEFAULT_CONTENT_TYPE,
+    onProgress,
+    abortSignal
+  } = options;
+  const { headers: mergedHeaders, timeout, withCredentials } = config;
+  return new Promise((resolve, reject) => {
+    const xhr = new XMLHttpRequest();
+    const startTime = Date.now();
+    if (timeout > 0) xhr.timeout = timeout;
+    xhr.addEventListener(
+      "timeout",
+      () => reject(
+        new ApiPackageError("Upload timed out", void 0, API_ERROR_CODES$1.REQUEST_TIMEOUT, {
+          context: { url: resolvedUrl }
+        })
+      )
+    );
+    xhr.upload.addEventListener("progress", (event) => {
+      if (!event.lengthComputable || !onProgress) return;
+      const elapsed = (Date.now() - startTime) / TIME_CONSTANTS.SECOND;
+      const speed = elapsed > 0 ? event.loaded / elapsed : 0;
+      const remaining = event.total - event.loaded;
+      onProgress({
+        loaded: event.loaded,
+        total: event.total,
+        percentage: Math.round(event.loaded / event.total * UPLOAD_CONSTANTS.FULL_PERCENTAGE),
+        speed,
+        estimatedTimeRemaining: speed > 0 ? remaining / speed : void 0
+      });
+    });
+    xhr.addEventListener("load", () => {
+      const success = xhr.status >= HTTP_STATUS.OK && xhr.status < HTTP_STATUS.MULTIPLE_CHOICES;
+      const responseHeaders = {};
+      const headerLines = xhr.getAllResponseHeaders().trim().split("\n");
+      for (const line of headerLines) {
+        const [key, ...valueParts] = line.split(":");
+        if (key) responseHeaders[key.trim().toLowerCase()] = valueParts.join(":").trim();
+      }
+      resolve({
+        status: xhr.status,
+        statusText: xhr.statusText,
+        data: xhr.responseText || void 0,
+        headers: responseHeaders,
+        success
+      });
+    });
+    xhr.addEventListener(
+      "error",
+      () => reject(
+        new ApiPackageError(
+          `Upload failed: ${xhr.statusText || "Network error"}`,
+          void 0,
+          API_ERROR_CODES$1.NETWORK_ERROR,
+          { context: { url: resolvedUrl, statusText: xhr.statusText } }
+        )
+      )
+    );
+    xhr.addEventListener(
+      "abort",
+      () => reject(
+        new ApiPackageError("Upload aborted", void 0, API_ERROR_CODES$1.REQUEST_ABORTED, {
+          context: { url: resolvedUrl }
+        })
+      )
+    );
+    if (abortSignal) abortSignal.addEventListener("abort", () => xhr.abort());
+    xhr.open(method, resolvedUrl);
+    if (withCredentials) xhr.withCredentials = true;
+    xhr.setRequestHeader("Content-Type", contentType);
+    for (const [key, value] of Object.entries(mergedHeaders)) xhr.setRequestHeader(key, value);
+    if (data instanceof Blob || data instanceof ArrayBuffer) {
+      xhr.send(data);
+    } else if (data instanceof Uint8Array) {
+      xhr.send(new Uint8Array(data));
+    } else {
+      xhr.send(data);
+    }
+  });
+}
+__name(uploadOnce2, "uploadOnce");
+async function uploadWithProgressBrowser(options) {
+  const config = getMergedConfig(options);
+  const resolvedUrl = resolveUrl(options.url, config.baseURL);
+  const maxAttempts = config.retry ? (config.retry.attempts ?? 0) + 1 : 1;
+  let lastError;
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    const ctx = { config, maxAttempts, attempt };
+    try {
+      const result = await uploadOnce2(options, config, resolvedUrl);
+      if (shouldRetryResult(result, config, attempt, maxAttempts)) {
+        notifyRetryError({
+          ctx,
+          message: `Upload failed: ${result.status}`,
+          status: result.status,
+          statusText: result.statusText
+        });
+        await handleRetryDelay(attempt, config.retry);
+        continue;
+      }
+      return { ...result, attempts: attempt };
+    } catch (error) {
+      lastError = normalizeError2(error);
+      if (shouldRetryError(lastError, config, attempt, maxAttempts)) {
+        notifyRetryError({ ctx, message: lastError.message, cause: lastError });
+        await handleRetryDelay(attempt, config.retry);
+        continue;
+      }
+      notifyFinalError(ctx, lastError);
+      throw lastError;
+    }
+  }
+  throw lastError ?? new ApiPackageError(
+    "Upload failed after all retry attempts",
+    void 0,
+    API_ERROR_CODES$1.NETWORK_ERROR
+  );
+}
+__name(uploadWithProgressBrowser, "uploadWithProgressBrowser");
+
+// src/api/upload/uploadWithProgress.ts
+async function uploadWithProgress(options) {
+  if (isNode()) {
+    return uploadWithProgressNode(options);
+  }
+  return uploadWithProgressBrowser(options);
+}
+__name(uploadWithProgress, "uploadWithProgress");
 
 // src/api/hooks/factories/defaults.ts
 var DEFAULT_QUERY_OPTIONS = {};
@@ -24380,13 +24951,13 @@ function isAbortError(error) {
   return message.includes("abort") || message.includes("cancel");
 }
 __name(isAbortError, "isAbortError");
-function createAbortError(message = "Request aborted") {
+function createAbortError2(message = "Request aborted") {
   if (message === null || message === void 0) {
     return "Request aborted";
   }
   return message;
 }
-__name(createAbortError, "createAbortError");
+__name(createAbortError2, "createAbortError");
 
 // src/api/request/tracker.ts
 var RequestTracker = class {
@@ -24436,7 +25007,7 @@ var RequestTracker = class {
       controller.abort(reason);
       this.unregister(key);
     }
-    void abortRequest(key, createAbortError(reason ?? "Request aborted"));
+    void abortRequest(key, createAbortError2(reason ?? "Request aborted"));
   }
   /**
    * Abort all requests in a group
@@ -24462,7 +25033,7 @@ var RequestTracker = class {
     });
     this.activeRequests.clear();
     this.requestGroups.clear();
-    void abortRequest("*", createAbortError(reason ?? "All requests aborted"));
+    void abortRequest("*", createAbortError2(reason ?? "All requests aborted"));
   }
   /**
    * Get active request count
@@ -24519,14 +25090,14 @@ function useRequestCleanup() {
   }, "untrackRequest");
   const abortTracked = /* @__PURE__ */ __name((reason) => {
     requestKeys.current.forEach((key) => {
-      void abortRequest(key, createAbortError(reason ?? "Manual abort"));
+      void abortRequest(key, createAbortError2(reason ?? "Manual abort"));
     });
     requestKeys.current.clear();
   }, "abortTracked");
   useEffect(() => {
     return () => {
       requestKeys.current.forEach((key) => {
-        void abortRequest(key, createAbortError("Component unmounted"));
+        void abortRequest(key, createAbortError2("Component unmounted"));
       });
       requestKeys.current.clear();
     };
@@ -24547,14 +25118,14 @@ function useAbortableRequest(key) {
         controllerRef.current.abort("Component unmounted or dependency changed");
         requestTracker.unregister(key);
       }
-      void abortRequest(key, createAbortError("Request cancelled"));
+      void abortRequest(key, createAbortError2("Request cancelled"));
     };
   }, [key]);
   const abort = /* @__PURE__ */ __name((reason) => {
     if (controllerRef.current) {
       controllerRef.current.abort(reason);
     }
-    void abortRequest(key, createAbortError(reason ?? "Request aborted by user"));
+    void abortRequest(key, createAbortError2(reason ?? "Request aborted by user"));
   }, "abort");
   return {
     signal,
@@ -24616,9 +25187,9 @@ function setupRouteChangeCleanup(router, options = {}) {
       }
       const pattern = options.abortPattern ?? "*";
       if (options.preservePatterns && options.preservePatterns.length > 0) {
-        void abortRequest(pattern, createAbortError(`Route changed to ${url}`));
+        void abortRequest(pattern, createAbortError2(`Route changed to ${url}`));
       } else {
-        void abortRequest(pattern, createAbortError(`Route changed to ${url}`));
+        void abortRequest(pattern, createAbortError2(`Route changed to ${url}`));
       }
     }, "executeAbort");
     if (options.delay && options.delay > 0) {
@@ -24665,7 +25236,7 @@ function createRouteGuard(pattern = "*") {
     }, "enter"),
     leave: /* @__PURE__ */ __name((reason) => {
       if (isActive) {
-        void abortRequest(pattern, createAbortError(reason ?? "Leaving route"));
+        void abortRequest(pattern, createAbortError2(reason ?? "Leaving route"));
         isActive = false;
       }
     }, "leave"),
@@ -24697,7 +25268,7 @@ __name(createRouteScope, "createRouteScope");
 
 // src/api/request/utils.ts
 function abortByPattern(pattern, reason) {
-  void abortRequest(pattern, createAbortError(reason ?? `Requests matching ${pattern} aborted`));
+  void abortRequest(pattern, createAbortError2(reason ?? `Requests matching ${pattern} aborted`));
 }
 __name(abortByPattern, "abortByPattern");
 function abortSearchRequests(reason) {
@@ -24715,25 +25286,25 @@ __name(abortAllRequests, "abortAllRequests");
 function createScopedAbort(scope) {
   return (key, reason) => {
     const fullKey = key.startsWith("/") ? `${scope}${key}` : `${scope}/${key}`;
-    void abortRequest(fullKey, createAbortError(reason ?? "Scoped request aborted"));
+    void abortRequest(fullKey, createAbortError2(reason ?? "Scoped request aborted"));
   };
 }
 __name(createScopedAbort, "createScopedAbort");
 function createDebouncedAbort(delay = 300) {
   return debounce((key, reason) => {
-    void abortRequest(key, createAbortError(reason ?? "Debounced abort"));
+    void abortRequest(key, createAbortError2(reason ?? "Debounced abort"));
   }, delay);
 }
 __name(createDebouncedAbort, "createDebouncedAbort");
 function createThrottledAbort(limit = 1e3) {
   return throttle((key, reason) => {
-    void abortRequest(key, createAbortError(reason ?? "Throttled abort"));
+    void abortRequest(key, createAbortError2(reason ?? "Throttled abort"));
   }, limit);
 }
 __name(createThrottledAbort, "createThrottledAbort");
 async function requestWithTimeout(key, fetcher, timeoutMs) {
   const timeoutId = setTimeout(() => {
-    void abortRequest(key, createAbortError(`Request timeout after ${timeoutMs}ms`));
+    void abortRequest(key, createAbortError2(`Request timeout after ${timeoutMs}ms`));
   }, timeoutMs);
   try {
     return await fetcher();
@@ -24746,7 +25317,7 @@ async function raceRequests(requests) {
   const abortLosers = /* @__PURE__ */ __name((winnerKey) => {
     requests.forEach((req) => {
       if (req.key !== winnerKey) {
-        void abortRequest(req.key, createAbortError("Lost race"));
+        void abortRequest(req.key, createAbortError2("Lost race"));
       }
     });
   }, "abortLosers");
@@ -24767,7 +25338,7 @@ async function sequentialRequests(requests) {
       results.push(result);
     } catch (error) {
       for (let j = i + 1; j < requests.length; j++) {
-        void abortRequest(requests[j].key, createAbortError("Previous request in chain failed"));
+        void abortRequest(requests[j].key, createAbortError2("Previous request in chain failed"));
       }
       throw error;
     }
@@ -26874,6 +27445,6 @@ function ApiProvider({
 }
 __name(ApiProvider, "ApiProvider");
 
-export { ALL_EVENTS, ApiInitializationError, ApiInitializationLoading, ApiPackageError, ApiProvider, CACHE_EVENTS2 as CACHE_EVENTS, CLIENT_EVENTS2 as CLIENT_EVENTS, CONFIG_EVENTS2 as CONFIG_EVENTS, ClientEventManager, ClientHintsInterceptor, ConfigBuilder, DEBUG_EVENTS2 as DEBUG_EVENTS, ERROR_EVENTS2 as ERROR_EVENTS, EVENT_NAMESPACES2 as EVENT_NAMESPACES, EVENT_SCOPES, EVENT_SCOPES_WITH_TEMPORARY2 as EVENT_SCOPES_WITH_TEMPORARY, Environment, EventHelpers, EventManager, HANDLER_SCOPES, HEADER_EVENTS2 as HEADER_EVENTS, HeaderBuilder, IntervalManager, MEDIA_EXTENSIONS, MEDIA_MIME_PREFIXES, MinimumConnectionGuard, NETWORK_EVENTS2 as NETWORK_EVENTS, NetworkConfigurationManager, NetworkDetectionMiddleware, NetworkGuard, NetworkInfoParam, NetworkPresetNames, NetworkProperty, NoDataSaverGuard, PERFORMANCE_EVENTS2 as PERFORMANCE_EVENTS, RequestTracker, UnifiedDebugger, abortAllRequests, abortByPattern, abortRequest, abortSearchRequests, abortUploadRequests, addClientHintsToResponse, addInterval, addTime, analyzeComplianceIssues, analyzeConfigImpact, analyzeConflictPatterns, analyzeEventSystemIssues, analyzeHistoryPatterns, analyzePerformanceIssues, applyCacheStrategyConfig, applyConfigOverride, applyConfigPreset, applyConfigUpdate, applyCustomQualityPresetStrategies, applyHeaderPresets, applyIndividualStrategies, applyPerformancePresetConfig, applyPollingStrategy, applyPollingStrategyConfig, applyRetryStrategy, applyRetryStrategyConfig, applyRevalidationStrategy, applyTemporaryNetworkOverride, applyUnifiedStrategy, applyUnifiedStrategyToConfig, arrayOf, average, base64ToBytes, buildCacheKey, buildEndpointUrl, buildFullUrl, buildUrl, bulkValidateInfobipEmails, bytesToBase64, cacheKeyPatterns, cacheStrategies, calculateCacheDuration, calculatePerformanceImpact, calculatePollingDuration, calculateRequestMetrics, campaignEndpoints, canPerformHeavyOperation, cdnEndpoints, checkFeatureFlagEnabled, checkOverrideTriggers, clamp, clampedPercentage, clearErrorHandlers, clearNetworkDebugData, clearTemporaryOverrides, cloneConfig, cloudFrontCreateInvalidation, cloudFrontEndpoints, cloudflareEndpoints, cloudflarePurgeCache, compactHistory, configConflictDetector, configureForEnvironment, containsAny, convertEndpointsToFetchff, createAbortError, createAdaptiveResponse, createApiClient, createCachePattern, createCacheStrategy, createCampaign, createComplianceReport, createConditionalInterval, createConditionalPolling, createConfigBuilder, createConfigHistoryEntry, createConfigState, createConflict, createCustomPreset, createCustomUnifiedStrategy, createDate, createDebouncedAbort, createDebugReport, createDecryptionInterceptor, createDelay, createEncryptionInterceptor, createEncryptionInterceptors, createEventEmitter, createFeatureFlag, createHistoryEntry, createHistorySummary, createLimitedInterval, createManagedInterval, createNetworkDetectionMiddleware, createPerformanceAnalysis, createPerformanceBenchmark, createPollingStrategy, createPreservedConfig, createProgressivePolling, createRetryConfig, createRetryStrategy, createRevalidationKey, createRevalidationStrategy, createRouteGuard, createRouteScope, createScopedAbort, createStatusCodeLimits, createThrottledAbort, createTypedSubscription, createVisibilityAwarePolling, dateDiff, debounce, decrypt, deepMerge, deleteCache, deleteCampaign, deleteFeatureFlag, deleteFile, detectConfigConflicts, detectConflicts, detectPlatform, determinePrecedenceReason, disableNetworkConfigDebug, downloadFile, enableNetworkConfigDebug, encrypt, endOfDay, endpointCacheKey, endpointCachePattern, endpointCachePatterns, endpoints, evaluateAllFeatureFlags, evaluateFeatureFlag, eventManager, exportKeyToBase64, extendPresets as extendRevalidationPresets, extractFields, extractUrlParams, fastlyEndpoints, fastlyPurgeUrl, featureFlagEndpoints, fetchCampaign, fetchCampaignParticipants, fetchCampaignStats, fetchCampaigns, fetchFeatureFlagHealth, fetchFeatureFlagRules, fetchInfobipEmailLogs, fetchInfobipEmailReports, fetchInfobipScheduledEmailStatuses, fetchInfobipScheduledEmails, fetchInfobipValidations, filesEndpoints, filterHistory, filterObject, findEndpointsByPattern, findMatchingPaths, flattenObject, formatDuration, formatReportForConsole, formatTimeForInterval, fromFetchffConfig, fromISOString, fromUnixTimestamp, generateComprehensiveReport, generateDocument, generateIV, generateIssueBreakdown, generateRandomKey, generateRecommendations, generateUUID, getActiveOverrideKeys, getAdaptiveApiConfig, getAdaptiveBatchSize, getAdaptiveCacheDuration, getAdaptiveConfig, getAdaptivePageSize, getAdaptiveTimeout, getAllEndpointUrls, getAllFieldPaths, getAllMediaExtensions, getAnalysisResult, getAppVersion, getAuthenticationType, getCache, getCacheAffectingHeaders, getCacheStrategy, getClientHintHeaders, getConfigHierarchy, getConnection, getConnectionType, getConsole, getContextHeaders, getCrypto, getDefaultApiClient, getDeviceId, getDeviceInfo, getDocument, getEffectiveConfig, getEffectiveConnectionType, getEndpointConfig, getEndpointMetadata, getEndpointParams, getEndpointUrl, getEndpointsByMethod, getEnhancedClientHints, getEntries, getEnv, getEnvironmentInfo, getEnvironmentName, getErrorHandlers, getEventManager, getExtendedEnvironmentInfo, getFieldValue, getFile, getFileExtension, getFrameworkAdaptiveBatchSize, getFrameworkAdaptiveTimeout, getGlobal, getGlobalConfig, getHeaderFingerprint, getHeaderSummary, getISOWeek, getIntervalBoundaries, getIntervalDifference, getIntervalEnd, getIntervalStart, getJSONSize, getKeys, getLocalStorage, getLocation, getMatchingPresets, getNavigator, getNetworkConfigFromHeaders, getNetworkDebugStats, getNetworkEventStats, getNetworkInfo, getNetworkInfoFromHeaders, getNetworkInfoFromRequest, getNetworkOptimizedConfig, getNetworkPreset, getNetworkQuality, getNetworkQualityFromHeaders, getNetworkQualityScore, getNetworkQualityWithThresholds, getNetworkRTT, getNetworkSpeed, getNonCacheAffectingHeaders, getOptimizedNetworkConfig, getPresetForNetworkInfo, getPresetForQuality, getPresetNames, getProcess, getQuarter, getQueryClient, getRelativeTime, getRetryStrategy, getPreset as getRevalidationPreset, getPresets as getRevalidationPresets, getRevalidationStrategy, getRuntimeEnvironment, getSSRSafeConfig, getSSRSafePollingConfig, getSessionStorage, getSignedUrl, getTimeComponents, getUnifiedDebugger, getUnifiedStrategy, getUnifiedStrategyNames, getUnixTimestamp, getUserAgent, getValues, getWindow, groupBy, handleArrayMerge, handleObjectMerge, hasAnyExtension, hasAuthentication, hasEncryptableFields, hasEndpoint, hasGlobal, hasIndexedDB, hasLocalStorage, hasMatchingFields, hasNavigator, hasNetworkInfo2 as hasNetworkInfoExpress, hasNetworkInfo as hasNetworkInfoNextjs, hasPathParams, hasPreset, hasProperty, hasSessionStorage, hasWebGL, hasWebPSupport, headerPresets, headers, headersContext, importKey, inBrowser, inRange, inServer, infobipEmailEndpoints, infobipEndpoints, invalidationScenarios, inverseLerp, isAbortError, isArray, isBoolean, isBrowser, isBun, isCI, isCacheValid, isCellularConnection, isCryptoAvailable, isDataFresh, isDataSaverEnabled, isDataSaverEnabledFromHeaders, isDebug, isDeno, isDevelopment, isDocumentVisible, isElectron, isEmpty, isEmptyObject, isEncryptedMetadata, isError, isFunction, isFuture, isInIframe, isInRange, isInteger, isMergeableObject, isMobile, isNetworkAPISupported, isNode, isNonEmptyArray, isNonEmptyObject, isNonEmptyString2 as isNonEmptyString, isNonNegativeNumber, isNotNullish, isNullish, isNumber, isObject, isOffline, isOneOfIgnoreCase, isOnline, isPageFocused, isPast, isPlainObject, isPollingActive, isPositiveNumber, isProduction, isPromise, isReactNative, isRevalidationSupported, isSSR, isSameDay, isSameInterval, isServer, isSlowConnection, isStaging, isString, isTest, isToday, isTouchDevice, isUnifiedStrategyName, isValidDate, isValidEnumValue, isValidFieldPath, isValidJSON, isValidNumber2 as isValidNumber, isValidPollingConfig, isValidStrategyName as isValidRevalidationStrategyName, isWebWorker, isWifiConnection, isWildcard, isWithinDedupeWindow, joinCampaign, jsonClone, jsonEquals, keyBy, leaveCampaign, lerp, logNetworkConfigReport, mapKeys, mapObject, mapRange, matchFieldPath, matchesAny, max, median, mergeCacheStrategies, mergeConfigs, mergeConflicts, mergeHeaders, mergePollingConfigs, mergePresets, mergeRetryStrategies, mergeRevalidationStrategies, mergeUnifiedStrategy, min, msToSeconds, mutate2 as mutate, networkConfigDebugger, networkConfigManager, networkDetectionMiddleware, networkPresets, networkStatus, normalizeHeaders2 as normalizeHeaders, now, nowInSeconds, omit, onOffline, onOnline, onceErrorHandler, oneOf, parseAndValidateNumber, parseFieldPath, percentage, pick, pollingEndpoints, pollingStrategies, prepareRequestConfig, prepareRequestConfigWithEnrichedHeaders, prettyStringify, processHeaders2 as processHeaders, raceRequests, randomBetween, randomInt, refreshFeatureFlagCache, registerErrorHandler, registerErrorHandlers, removeCircularReferences, removeEmpty, removeFeatureFlagOverride, removeNullish, removeSensitiveHeaders, removeUndefined, requestTracker, requestWithTimeout, rescheduleInfobipEmails, resetGlobalConfig, resetQueryClient, resetPresets as resetRevalidationPresets, resolveConflict, retryConditions, retryStrategies, genericPresets as revalidationPresets, revalidationStrategies, round, runWithHeaders, runWithHeadersAsync, safeParseJSON, safeStringify, sanitizeHeaders, secondsToMs, sendInfobipAdvancedEmail, sendInfobipEmail, sequentialRequests, setCache, setConfigWarnings, setDefaultApiClient, setErrorHandlers, setFeatureFlagOverride, setFieldValue, setGlobalConfig, setupClientEvents, setupNetworkMonitoring, setupRouteChangeCleanup, setupTemporaryOverride, shouldApplyConfig, shouldAutoRefresh, shouldPrefetch, shouldServeHighQuality, shouldUseAggressiveCaching, sleep, sortIssuesByPriority, startNetworkEventMonitoring, startOfDay, startRequestTracking, subscribe, subscribeMultiple, subscribeOnce, subscribeWithTimeout, sum, supportsBroadcastChannel, supportsFetch, supportsGeolocation, supportsIntersectionObserver, supportsLocalStorage, supportsNotifications, supportsPushNotifications, supportsRequestIdleCallback, supportsServiceWorker, supportsSessionStorage, supportsWebSocket, throttle, timeAgo, toFetchffConfig, toFetchffRevalidationConfig, toISOString, trackConfig, trackDirectCacheConfig, trackNetworkOverride, trackSpreadProperties, trackableSpread, transformFields, truncateJSON, unifiedStrategies, unregisterErrorHandlers, updateCampaign, updateFeatureFlag, updateGlobalConfig, updateInfobipScheduledEmailStatuses, uploadFile, uploadFileForScanning, uploadFiles, useAbortableRequest, useApiConfigConflicts, useApiDebugInfo, useApiMonitor, useApiNetworkQuality, useCampaign, useCampaignParticipants, useCampaignStats, useCampaigns, useCheckFeatureFlagEnabled, useConditionalSubscription, useCreateCampaign, useCreateFeatureFlag, useDebouncedSubscription, useDeleteCampaign, useDeleteFeatureFlag, useDeleteFile, useDownloadFile, useEvaluateAllFeatureFlags, useGenerateDocument, useGetFile, useGetSignedUrl, useJoinCampaign, useLeaveCampaign, useMultipleSubscriptions, useOptimisticUpdate, useRealTimeData, useRemoveFeatureFlagOverride, useRequestCleanup, useRequestGroup, useRouteAwareRequest, useSubscription, useSubscriptionState, useUpdateCampaign, useUpdateFeatureFlag, useUploadFile, useUploadFiles, validateConfigUpdate, validateEncryptionConfig, validateHeaders, validateInfobipEmail, validatePathParams, validatePreset, virusTotalEndpoints, waitForOnline, withNetworkDetection, withNetworkInfo, withTimeout };
+export { ALL_EVENTS, ApiInitializationError, ApiInitializationLoading, ApiPackageError, ApiProvider, CACHE_EVENTS2 as CACHE_EVENTS, CLIENT_EVENTS2 as CLIENT_EVENTS, CONFIG_EVENTS2 as CONFIG_EVENTS, ClientEventManager, ClientHintsInterceptor, ConfigBuilder, DEBUG_EVENTS2 as DEBUG_EVENTS, ERROR_EVENTS2 as ERROR_EVENTS, EVENT_NAMESPACES2 as EVENT_NAMESPACES, EVENT_SCOPES, EVENT_SCOPES_WITH_TEMPORARY2 as EVENT_SCOPES_WITH_TEMPORARY, Environment, EventHelpers, EventManager, HANDLER_SCOPES, HEADER_EVENTS2 as HEADER_EVENTS, HeaderBuilder, IntervalManager, MEDIA_EXTENSIONS, MEDIA_MIME_PREFIXES, MinimumConnectionGuard, NETWORK_EVENTS2 as NETWORK_EVENTS, NetworkConfigurationManager, NetworkDetectionMiddleware, NetworkGuard, NetworkInfoParam, NetworkPresetNames, NetworkProperty, NoDataSaverGuard, PERFORMANCE_EVENTS2 as PERFORMANCE_EVENTS, RequestTracker, UnifiedDebugger, abortAllRequests, abortByPattern, abortRequest, abortSearchRequests, abortUploadRequests, addClientHintsToResponse, addInterval, addTime, analyzeComplianceIssues, analyzeConfigImpact, analyzeConflictPatterns, analyzeEventSystemIssues, analyzeHistoryPatterns, analyzePerformanceIssues, applyCacheStrategyConfig, applyConfigOverride, applyConfigPreset, applyConfigUpdate, applyCustomQualityPresetStrategies, applyHeaderPresets, applyIndividualStrategies, applyPerformancePresetConfig, applyPollingStrategy, applyPollingStrategyConfig, applyRetryStrategy, applyRetryStrategyConfig, applyRevalidationStrategy, applyTemporaryNetworkOverride, applyUnifiedStrategy, applyUnifiedStrategyToConfig, arrayOf, average, base64ToBytes, buildCacheKey, buildEndpointUrl, buildFullUrl, buildUrl, bulkValidateInfobipEmails, bytesToBase64, cacheKeyPatterns, cacheStrategies, calculateCacheDuration, calculatePerformanceImpact, calculatePollingDuration, calculateRequestMetrics, campaignEndpoints, canPerformHeavyOperation, cdnEndpoints, checkFeatureFlagEnabled, checkOverrideTriggers, clamp, clampedPercentage, clearErrorHandlers, clearNetworkDebugData, clearTemporaryOverrides, cloneConfig, cloudFrontCreateInvalidation, cloudFrontEndpoints, cloudflareEndpoints, cloudflarePurgeCache, compactHistory, configConflictDetector, configureForEnvironment, containsAny, convertEndpointsToFetchff, createAbortError2 as createAbortError, createAdaptiveResponse, createApiClient, createCachePattern, createCacheStrategy, createCampaign, createComplianceReport, createConditionalInterval, createConditionalPolling, createConfigBuilder, createConfigHistoryEntry, createConfigState, createConflict, createCustomPreset, createCustomUnifiedStrategy, createDate, createDebouncedAbort, createDebugReport, createDecryptionInterceptor, createDelay, createEncryptionInterceptor, createEncryptionInterceptors, createEventEmitter, createFeatureFlag, createHistoryEntry, createHistorySummary, createLimitedInterval, createManagedInterval, createNetworkDetectionMiddleware, createPerformanceAnalysis, createPerformanceBenchmark, createPollingStrategy, createPreservedConfig, createProgressivePolling, createRetryConfig, createRetryStrategy, createRevalidationKey, createRevalidationStrategy, createRouteGuard, createRouteScope, createScopedAbort, createStatusCodeLimits, createThrottledAbort, createTypedSubscription, createVisibilityAwarePolling, dateDiff, debounce, decrypt, deepMerge, deleteCache, deleteCampaign, deleteFeatureFlag, deleteFile, detectConfigConflicts, detectConflicts, detectPlatform, determinePrecedenceReason, disableNetworkConfigDebug, downloadFile, enableNetworkConfigDebug, encrypt, endOfDay, endpointCacheKey, endpointCachePattern, endpointCachePatterns, endpoints, evaluateAllFeatureFlags, evaluateFeatureFlag, eventManager, exportKeyToBase64, extendPresets as extendRevalidationPresets, extractFields, extractUrlParams, fastlyEndpoints, fastlyPurgeUrl, featureFlagEndpoints, fetchCampaign, fetchCampaignParticipants, fetchCampaignStats, fetchCampaigns, fetchFeatureFlagHealth, fetchFeatureFlagRules, fetchInfobipEmailLogs, fetchInfobipEmailReports, fetchInfobipScheduledEmailStatuses, fetchInfobipScheduledEmails, fetchInfobipValidations, filesEndpoints, filterHistory, filterObject, findEndpointsByPattern, findMatchingPaths, flattenObject, formatDuration, formatReportForConsole, formatTimeForInterval, fromFetchffConfig, fromISOString, fromUnixTimestamp, generateComprehensiveReport, generateDocument, generateIV, generateIssueBreakdown, generateRandomKey, generateRecommendations, generateUUID, getActiveOverrideKeys, getAdaptiveApiConfig, getAdaptiveBatchSize, getAdaptiveCacheDuration, getAdaptiveConfig, getAdaptivePageSize, getAdaptiveTimeout, getAllEndpointUrls, getAllFieldPaths, getAllMediaExtensions, getAnalysisResult, getAppVersion, getAuthenticationType, getCache, getCacheAffectingHeaders, getCacheStrategy, getClientHintHeaders, getConfigHierarchy, getConnection, getConnectionType, getConsole, getContextHeaders, getCrypto, getDefaultApiClient, getDeviceId, getDeviceInfo, getDocument, getEffectiveConfig, getEffectiveConnectionType, getEndpointConfig, getEndpointMetadata, getEndpointParams, getEndpointUrl, getEndpointsByMethod, getEnhancedClientHints, getEntries, getEnv, getEnvironmentInfo, getEnvironmentName, getErrorHandlers, getEventManager, getExtendedEnvironmentInfo, getFieldValue, getFile, getFileExtension, getFrameworkAdaptiveBatchSize, getFrameworkAdaptiveTimeout, getGlobal, getGlobalConfig, getHeaderFingerprint, getHeaderSummary, getISOWeek, getIntervalBoundaries, getIntervalDifference, getIntervalEnd, getIntervalStart, getJSONSize, getKeys, getLocalStorage, getLocation, getMatchingPresets, getNavigator, getNetworkConfigFromHeaders, getNetworkDebugStats, getNetworkEventStats, getNetworkInfo, getNetworkInfoFromHeaders, getNetworkInfoFromRequest, getNetworkOptimizedConfig, getNetworkPreset, getNetworkQuality, getNetworkQualityFromHeaders, getNetworkQualityScore, getNetworkQualityWithThresholds, getNetworkRTT, getNetworkSpeed, getNonCacheAffectingHeaders, getOptimizedNetworkConfig, getPresetForNetworkInfo, getPresetForQuality, getPresetNames, getProcess, getQuarter, getQueryClient, getRelativeTime, getRetryStrategy, getPreset as getRevalidationPreset, getPresets as getRevalidationPresets, getRevalidationStrategy, getRuntimeEnvironment, getSSRSafeConfig, getSSRSafePollingConfig, getSessionStorage, getSignedUrl, getTimeComponents, getUnifiedDebugger, getUnifiedStrategy, getUnifiedStrategyNames, getUnixTimestamp, getUserAgent, getValues, getWindow, groupBy, handleArrayMerge, handleObjectMerge, hasAnyExtension, hasAuthentication, hasEncryptableFields, hasEndpoint, hasGlobal, hasIndexedDB, hasLocalStorage, hasMatchingFields, hasNavigator, hasNetworkInfo2 as hasNetworkInfoExpress, hasNetworkInfo as hasNetworkInfoNextjs, hasPathParams, hasPreset, hasProperty, hasSessionStorage, hasWebGL, hasWebPSupport, headerPresets, headers, headersContext, importKey, inBrowser, inRange, inServer, infobipEmailEndpoints, infobipEndpoints, invalidationScenarios, inverseLerp, isAbortError, isArray, isBoolean, isBrowser, isBun, isCI, isCacheValid, isCellularConnection, isCryptoAvailable, isDataFresh, isDataSaverEnabled, isDataSaverEnabledFromHeaders, isDebug, isDeno, isDevelopment, isDocumentVisible, isElectron, isEmpty, isEmptyObject, isEncryptedMetadata, isError, isFunction, isFuture, isInIframe, isInRange, isInteger, isMergeableObject, isMobile, isNetworkAPISupported, isNode, isNonEmptyArray, isNonEmptyObject, isNonEmptyString2 as isNonEmptyString, isNonNegativeNumber, isNotNullish, isNullish, isNumber, isObject, isOffline, isOneOfIgnoreCase, isOnline, isPageFocused, isPast, isPlainObject, isPollingActive, isPositiveNumber, isProduction, isPromise, isReactNative, isRevalidationSupported, isSSR, isSameDay, isSameInterval, isServer, isSlowConnection, isStaging, isString, isTest, isToday, isTouchDevice, isUnifiedStrategyName, isValidDate, isValidEnumValue, isValidFieldPath, isValidJSON, isValidNumber2 as isValidNumber, isValidPollingConfig, isValidStrategyName as isValidRevalidationStrategyName, isWebWorker, isWifiConnection, isWildcard, isWithinDedupeWindow, joinCampaign, jsonClone, jsonEquals, keyBy, leaveCampaign, lerp, logNetworkConfigReport, mapKeys, mapObject, mapRange, matchFieldPath, matchesAny, max, median, mergeCacheStrategies, mergeConfigs, mergeConflicts, mergeHeaders, mergePollingConfigs, mergePresets, mergeRetryStrategies, mergeRevalidationStrategies, mergeUnifiedStrategy, min, msToSeconds, mutate2 as mutate, networkConfigDebugger, networkConfigManager, networkDetectionMiddleware, networkPresets, networkStatus, normalizeHeaders2 as normalizeHeaders, now, nowInSeconds, omit, onOffline, onOnline, onceErrorHandler, oneOf, parseAndValidateNumber, parseFieldPath, percentage, pick, pollingEndpoints, pollingStrategies, prepareRequestConfig, prepareRequestConfigWithEnrichedHeaders, prettyStringify, processHeaders2 as processHeaders, raceRequests, randomBetween, randomInt, refreshFeatureFlagCache, registerErrorHandler, registerErrorHandlers, removeCircularReferences, removeEmpty, removeFeatureFlagOverride, removeNullish, removeSensitiveHeaders, removeUndefined, requestTracker, requestWithTimeout, rescheduleInfobipEmails, resetGlobalConfig, resetQueryClient, resetPresets as resetRevalidationPresets, resolveConflict, retryConditions, retryStrategies, genericPresets as revalidationPresets, revalidationStrategies, round, runWithHeaders, runWithHeadersAsync, safeParseJSON, safeStringify, sanitizeHeaders, secondsToMs, sendInfobipAdvancedEmail, sendInfobipEmail, sequentialRequests, setCache, setConfigWarnings, setDefaultApiClient, setErrorHandlers, setFeatureFlagOverride, setFieldValue, setGlobalConfig, setupClientEvents, setupNetworkMonitoring, setupRouteChangeCleanup, setupTemporaryOverride, shouldApplyConfig, shouldAutoRefresh, shouldPrefetch, shouldServeHighQuality, shouldUseAggressiveCaching, sleep, sortIssuesByPriority, startNetworkEventMonitoring, startOfDay, startRequestTracking, subscribe, subscribeMultiple, subscribeOnce, subscribeWithTimeout, sum, supportsBroadcastChannel, supportsFetch, supportsGeolocation, supportsIntersectionObserver, supportsLocalStorage, supportsNotifications, supportsPushNotifications, supportsRequestIdleCallback, supportsServiceWorker, supportsSessionStorage, supportsWebSocket, throttle, timeAgo, toFetchffConfig, toFetchffRevalidationConfig, toISOString, trackConfig, trackDirectCacheConfig, trackNetworkOverride, trackSpreadProperties, trackableSpread, transformFields, truncateJSON, unifiedStrategies, unregisterErrorHandlers, updateCampaign, updateFeatureFlag, updateGlobalConfig, updateInfobipScheduledEmailStatuses, uploadFile, uploadFileForScanning, uploadFiles, uploadWithProgress, useAbortableRequest, useApiConfigConflicts, useApiDebugInfo, useApiMonitor, useApiNetworkQuality, useCampaign, useCampaignParticipants, useCampaignStats, useCampaigns, useCheckFeatureFlagEnabled, useConditionalSubscription, useCreateCampaign, useCreateFeatureFlag, useDebouncedSubscription, useDeleteCampaign, useDeleteFeatureFlag, useDeleteFile, useDownloadFile, useEvaluateAllFeatureFlags, useGenerateDocument, useGetFile, useGetSignedUrl, useJoinCampaign, useLeaveCampaign, useMultipleSubscriptions, useOptimisticUpdate, useRealTimeData, useRemoveFeatureFlagOverride, useRequestCleanup, useRequestGroup, useRouteAwareRequest, useSubscription, useSubscriptionState, useUpdateCampaign, useUpdateFeatureFlag, useUploadFile, useUploadFiles, validateConfigUpdate, validateEncryptionConfig, validateHeaders, validateInfobipEmail, validatePathParams, validatePreset, virusTotalEndpoints, waitForOnline, withNetworkDetection, withNetworkInfo, withTimeout };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map