@fjell/client-api 4.4.16 → 4.4.18

package/dist/index.js

@@ -96,18 +96,119 @@ var getOneOperation = (api, apiOptions, utilities) => {
 
 // src/ops/create.ts
 var logger5 = logger_default.get("client-api", "ops", "create");
+function shouldRetryError(error) {
+  if (error.code === "ECONNREFUSED" || error.code === "ENOTFOUND" || error.code === "ENETUNREACH" || error.message?.includes("timeout") || error.message?.includes("network")) {
+    return true;
+  }
+  if (error.status >= 500 || error.status === 429) {
+    return true;
+  }
+  if (error.status >= 400 && error.status < 500 && error.status !== 429) {
+    return false;
+  }
+  return true;
+}
+function calculateRetryDelay(attempt, config) {
+  const exponentialDelay = (config.initialDelayMs || 1e3) * Math.pow(config.backoffMultiplier || 2, attempt);
+  const cappedDelay = Math.min(exponentialDelay, config.maxDelayMs || 3e4);
+  const jitter = 0.5 + Math.random() * 0.5;
+  return Math.floor(cappedDelay * jitter);
+}
+function enhanceError(error, context) {
+  if (!error) return new Error("Unknown error occurred");
+  if (error.context) return error;
+  const enhancedError = new Error(error.message || "HTTP operation failed");
+  Object.assign(enhancedError, {
+    code: error.code || error.status || "UNKNOWN_ERROR",
+    status: error.status,
+    context,
+    originalError: error
+  });
+  return enhancedError;
+}
 var getCreateOperation = (api, apiOptions, utilities) => {
   const create = async (item, locations = []) => {
     const requestOptions = Object.assign({}, apiOptions.postOptions, { isAuthenticated: apiOptions.writeAuthenticated });
     logger5.default("create", { item, locations, requestOptions });
     utilities.verifyLocations(locations);
     const loc = locations;
-    const created = utilities.validatePK(await utilities.processOne(api.httpPost(
-      utilities.getPath(loc),
-      item,
-      requestOptions
-    )));
-    return created;
+    const operationContext = {
+      operation: "create",
+      path: utilities.getPath(loc),
+      itemType: typeof item,
+      hasLocations: locations.length > 0
+    };
+    const retryConfig = {
+      maxRetries: 3,
+      initialDelayMs: 1e3,
+      maxDelayMs: 3e4,
+      backoffMultiplier: 2,
+      ...apiOptions.retryConfig
+    };
+    let lastError = null;
+    const startTime = Date.now();
+    for (let attempt = 0; attempt <= retryConfig.maxRetries; attempt++) {
+      try {
+        logger5.debug(`Creating item (attempt ${attempt + 1})`, operationContext);
+        const result = await utilities.processOne(api.httpPost(
+          utilities.getPath(loc),
+          item,
+          requestOptions
+        ));
+        const created = utilities.validatePK(result);
+        if (attempt > 0) {
+          logger5.info(`Create operation succeeded after ${attempt} retries`, {
+            ...operationContext,
+            totalAttempts: attempt + 1,
+            duration: Date.now() - startTime
+          });
+        }
+        return created;
+      } catch (error) {
+        lastError = error;
+        if (attempt === retryConfig.maxRetries) {
+          break;
+        }
+        const isRetryable = shouldRetryError(error);
+        if (!isRetryable) {
+          logger5.debug("Not retrying create operation due to non-retryable error", {
+            ...operationContext,
+            errorMessage: error.message,
+            errorCode: error.code || error.status,
+            attempt: attempt + 1
+          });
+          break;
+        }
+        const delay = calculateRetryDelay(attempt, retryConfig);
+        logger5.warning(`Retrying create operation (attempt ${attempt + 2}) after ${delay}ms`, {
+          ...operationContext,
+          errorMessage: error.message,
+          errorCode: error.code || error.status,
+          delay,
+          attemptNumber: attempt + 1
+        });
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      }
+    }
+    const finalError = enhanceError(lastError, operationContext);
+    if (apiOptions.errorHandler) {
+      try {
+        apiOptions.errorHandler(finalError, operationContext);
+      } catch (handlerError) {
+        logger5.error("Custom error handler failed", {
+          originalError: finalError.message,
+          handlerError: handlerError?.message || String(handlerError)
+        });
+      }
+    }
+    logger5.error(`Create operation failed after ${retryConfig.maxRetries + 1} attempts`, {
+      ...operationContext,
+      errorMessage: finalError.message,
+      errorCode: finalError.code || finalError.status,
+      duration: Date.now() - startTime,
+      totalAttempts: retryConfig.maxRetries + 1
+    });
+    throw finalError;
   };
   return create;
 };
@@ -131,16 +232,121 @@ var getUpdateOperation = (api, apiOptions, utilities) => {
 
 // src/ops/get.ts
 var logger7 = logger_default.get("client-api", "ops", "get");
+function shouldRetryError2(error) {
+  if (error.code === "ECONNREFUSED" || error.code === "ENOTFOUND" || error.code === "ENETUNREACH" || error.message?.includes("timeout") || error.message?.includes("network")) {
+    return true;
+  }
+  if (error.status >= 500 || error.status === 429) {
+    return true;
+  }
+  if (error.status >= 400 && error.status < 500 && error.status !== 429) {
+    return false;
+  }
+  return true;
+}
+function calculateRetryDelay2(attempt, config) {
+  const exponentialDelay = (config.initialDelayMs || 1e3) * Math.pow(config.backoffMultiplier || 2, attempt);
+  const cappedDelay = Math.min(exponentialDelay, config.maxDelayMs || 3e4);
+  const jitter = 0.5 + Math.random() * 0.5;
+  return Math.floor(cappedDelay * jitter);
+}
+function enhanceError2(error, context) {
+  if (!error) return new Error("Unknown error occurred");
+  if (error.context) return error;
+  const enhancedError = new Error(error.message || "HTTP operation failed");
+  Object.assign(enhancedError, {
+    code: error.code || error.status || "UNKNOWN_ERROR",
+    status: error.status,
+    context,
+    originalError: error
+  });
+  return enhancedError;
+}
 var getGetOperation = (api, apiOptions, utilities) => {
   const get = async (ik) => {
     const requestOptions = Object.assign({}, apiOptions.getOptions, { isAuthenticated: apiOptions.readAuthenticated });
     logger7.default("get", { ik, requestOptions });
-    return utilities.validatePK(await utilities.processOne(
-      api.httpGet(
-        utilities.getPath(ik),
-        requestOptions
-      )
-    ));
+    const operationContext = {
+      operation: "get",
+      path: utilities.getPath(ik),
+      keyType: typeof ik
+    };
+    const retryConfig = {
+      maxRetries: 3,
+      initialDelayMs: 1e3,
+      maxDelayMs: 3e4,
+      backoffMultiplier: 2,
+      ...apiOptions.retryConfig
+    };
+    let lastError = null;
+    const startTime = Date.now();
+    for (let attempt = 0; attempt <= retryConfig.maxRetries; attempt++) {
+      try {
+        logger7.debug(`Getting item (attempt ${attempt + 1})`, operationContext);
+        const result = await utilities.processOne(
+          api.httpGet(
+            utilities.getPath(ik),
+            requestOptions
+          )
+        );
+        const item = utilities.validatePK(result);
+        if (attempt > 0) {
+          logger7.info(`Get operation succeeded after ${attempt} retries`, {
+            ...operationContext,
+            totalAttempts: attempt + 1,
+            duration: Date.now() - startTime
+          });
+        }
+        return item;
+      } catch (error) {
+        lastError = error;
+        if (error.status === 404) {
+          logger7.debug("Item not found (404)", operationContext);
+          return null;
+        }
+        if (attempt === retryConfig.maxRetries) {
+          break;
+        }
+        const isRetryable = shouldRetryError2(error);
+        if (!isRetryable) {
+          logger7.debug("Not retrying get operation due to non-retryable error", {
+            ...operationContext,
+            errorMessage: error.message,
+            errorCode: error.code || error.status,
+            attempt: attempt + 1
+          });
+          break;
+        }
+        const delay = calculateRetryDelay2(attempt, retryConfig);
+        logger7.warning(`Retrying get operation (attempt ${attempt + 2}) after ${delay}ms`, {
+          ...operationContext,
+          errorMessage: error.message,
+          errorCode: error.code || error.status,
+          delay,
+          attemptNumber: attempt + 1
+        });
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      }
+    }
+    const finalError = enhanceError2(lastError, operationContext);
+    if (apiOptions.errorHandler) {
+      try {
+        apiOptions.errorHandler(finalError, operationContext);
+      } catch (handlerError) {
+        logger7.error("Custom error handler failed", {
+          originalError: finalError.message,
+          handlerError: handlerError?.message || String(handlerError)
+        });
+      }
+    }
+    logger7.error(`Get operation failed after ${retryConfig.maxRetries + 1} attempts`, {
+      ...operationContext,
+      errorMessage: finalError.message,
+      errorCode: finalError.code || finalError.status,
+      duration: Date.now() - startTime,
+      totalAttempts: retryConfig.maxRetries + 1
+    });
+    throw finalError;
   };
   return get;
 };
@@ -534,12 +740,510 @@ var createRegistry = (registryHub) => {
     ...baseRegistry
   };
 };
+
+// src/errors/index.ts
+var ClientApiError = class extends Error {
+  timestamp;
+  context;
+  constructor(message, context) {
+    super(message);
+    this.name = this.constructor.name;
+    this.timestamp = /* @__PURE__ */ new Date();
+    this.context = context;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      message: this.message,
+      isRetryable: this.isRetryable,
+      timestamp: this.timestamp,
+      context: this.context,
+      stack: this.stack
+    };
+  }
+};
+var NetworkError = class extends ClientApiError {
+  code = "NETWORK_ERROR";
+  isRetryable = true;
+  constructor(message, context) {
+    super(`Network error: ${message}`, context);
+  }
+};
+var TimeoutError = class extends ClientApiError {
+  code = "TIMEOUT_ERROR";
+  isRetryable = true;
+  constructor(timeout, context) {
+    super(`Request timed out after ${timeout}ms`, context);
+  }
+};
+var AuthenticationError = class extends ClientApiError {
+  code = "AUTHENTICATION_ERROR";
+  isRetryable = false;
+  constructor(message, context) {
+    super(message || "Authentication failed - invalid or expired credentials", context);
+  }
+};
+var AuthorizationError = class extends ClientApiError {
+  code = "AUTHORIZATION_ERROR";
+  isRetryable = false;
+  constructor(message, context) {
+    super(message || "Access forbidden - insufficient permissions", context);
+  }
+};
+var NotFoundError = class extends ClientApiError {
+  code = "NOT_FOUND_ERROR";
+  isRetryable = false;
+  constructor(resource, identifier, context) {
+    const message = identifier ? `${resource} with identifier '${identifier}' not found` : `${resource} not found`;
+    super(message, context);
+  }
+};
+var ValidationError = class extends ClientApiError {
+  code = "VALIDATION_ERROR";
+  isRetryable = false;
+  validationErrors;
+  constructor(message, validationErrors, context) {
+    super(`Validation error: ${message}`, context);
+    this.validationErrors = validationErrors;
+  }
+};
+var ConflictError = class extends ClientApiError {
+  code = "CONFLICT_ERROR";
+  isRetryable = false;
+  constructor(message, context) {
+    super(`Conflict: ${message}`, context);
+  }
+};
+var RateLimitError = class extends ClientApiError {
+  code = "RATE_LIMIT_ERROR";
+  isRetryable = true;
+  retryAfter;
+  constructor(retryAfter, context) {
+    const message = retryAfter ? `Rate limit exceeded - retry after ${retryAfter} seconds` : "Rate limit exceeded";
+    super(message, context);
+    this.retryAfter = retryAfter;
+  }
+};
+var ServerError = class extends ClientApiError {
+  code = "SERVER_ERROR";
+  isRetryable = true;
+  statusCode;
+  constructor(statusCode, message, context) {
+    super(message || `Server error (${statusCode})`, context);
+    this.statusCode = statusCode;
+  }
+};
+var PayloadTooLargeError = class extends ClientApiError {
+  code = "PAYLOAD_TOO_LARGE_ERROR";
+  isRetryable = false;
+  constructor(maxSize, context) {
+    const message = maxSize ? `Request payload too large - maximum size is ${maxSize}` : "Request payload too large";
+    super(message, context);
+  }
+};
+var HttpError = class extends ClientApiError {
+  code = "HTTP_ERROR";
+  isRetryable;
+  statusCode;
+  statusText;
+  constructor(statusCode, statusText, message, context) {
+    super(message || `HTTP error ${statusCode}: ${statusText}`, context);
+    this.statusCode = statusCode;
+    this.statusText = statusText;
+    this.isRetryable = statusCode >= 500;
+  }
+};
+var ConfigurationError = class extends ClientApiError {
+  code = "CONFIGURATION_ERROR";
+  isRetryable = false;
+  constructor(message, context) {
+    super(`Configuration error: ${message}`, context);
+  }
+};
+var ParseError = class extends ClientApiError {
+  code = "PARSE_ERROR";
+  isRetryable = false;
+  constructor(message, context) {
+    super(`Parse error: ${message}`, context);
+  }
+};
+function createHttpError(statusCode, statusText, responseBody, context) {
+  const errorContext = { statusCode, statusText, responseBody, ...context };
+  switch (statusCode) {
+    case 400:
+      if (responseBody?.validationErrors) {
+        return new ValidationError(
+          responseBody.message || "Request validation failed",
+          responseBody.validationErrors,
+          errorContext
+        );
+      }
+      return new ValidationError(responseBody?.message || statusText, [], errorContext);
+    case 401:
+      return new AuthenticationError(responseBody?.message, errorContext);
+    case 403:
+      return new AuthorizationError(responseBody?.message, errorContext);
+    case 404:
+      return new NotFoundError(
+        responseBody?.resource || "Resource",
+        responseBody?.identifier,
+        errorContext
+      );
+    case 409:
+      return new ConflictError(responseBody?.message || statusText, errorContext);
+    case 413:
+      return new PayloadTooLargeError(responseBody?.maxSize, errorContext);
+    case 429: {
+      let retryAfter;
+      if (responseBody?.retryAfter) {
+        retryAfter = responseBody.retryAfter;
+      } else if (context?.headers?.["retry-after"]) {
+        retryAfter = parseInt(context.headers["retry-after"]);
+      }
+      return new RateLimitError(retryAfter, errorContext);
+    }
+    default:
+      if (statusCode >= 500) {
+        return new ServerError(statusCode, responseBody?.message || statusText, errorContext);
+      }
+      return new HttpError(statusCode, statusText, responseBody?.message, errorContext);
+  }
+}
+function createNetworkError(error, context) {
+  const errorContext = { originalError: error, ...context };
+  if (error.code === "ECONNABORTED" || error.message?.includes("timeout")) {
+    return new TimeoutError(error.timeout || 5e3, errorContext);
+  }
+  if (error.code === "ECONNREFUSED" || error.code === "ENOTFOUND" || error.code === "ENETUNREACH" || error.message?.includes("network")) {
+    return new NetworkError(error.message || "Network connection failed", errorContext);
+  }
+  return new NetworkError(error.message || "Unknown network error", errorContext);
+}
+function isRetryableError(error) {
+  return error instanceof ClientApiError && error.isRetryable;
+}
+function isClientApiError(error) {
+  return error instanceof ClientApiError;
+}
+
+// src/ops/errorHandling.ts
+function shouldRetryError3(error) {
+  if (error.code === "ECONNREFUSED" || error.code === "ENOTFOUND" || error.code === "ENETUNREACH" || error.message?.includes("timeout") || error.message?.includes("network")) {
+    return true;
+  }
+  if (error.status >= 500 || error.status === 429) {
+    return true;
+  }
+  if (error.status >= 400 && error.status < 500 && error.status !== 429) {
+    return false;
+  }
+  return true;
+}
+function calculateRetryDelay3(attempt, config) {
+  const exponentialDelay = (config.initialDelayMs || 1e3) * Math.pow(config.backoffMultiplier || 2, attempt);
+  const cappedDelay = Math.min(exponentialDelay, config.maxDelayMs || 3e4);
+  const jitter = 0.5 + Math.random() * 0.5;
+  return Math.floor(cappedDelay * jitter);
+}
+function enhanceError3(error, context) {
+  if (!error) return new Error("Unknown error occurred");
+  if (error.context) return error;
+  const enhancedError = new Error(error.message || "HTTP operation failed");
+  Object.assign(enhancedError, {
+    code: error.code || error.status || "UNKNOWN_ERROR",
+    status: error.status,
+    context,
+    originalError: error
+  });
+  return enhancedError;
+}
+function getRetryConfig(apiOptions) {
+  return {
+    maxRetries: 3,
+    initialDelayMs: 1e3,
+    maxDelayMs: 3e4,
+    backoffMultiplier: 2,
+    ...apiOptions.retryConfig
+  };
+}
+function executeErrorHandler(errorHandler, error, context, logger21) {
+  if (!errorHandler) return;
+  try {
+    errorHandler(error, context);
+  } catch (handlerError) {
+    logger21.error("Custom error handler failed", {
+      originalError: error.message,
+      handlerError: handlerError?.message || String(handlerError)
+    });
+  }
+}
+async function executeWithRetry(operation, operationName, operationContext, apiOptions, logger21, specialErrorHandling) {
+  const retryConfig = getRetryConfig(apiOptions);
+  let lastError = null;
+  const startTime = Date.now();
+  for (let attempt = 0; attempt <= retryConfig.maxRetries; attempt++) {
+    try {
+      logger21.debug(`Executing ${operationName} (attempt ${attempt + 1})`, operationContext);
+      const result = await operation();
+      if (attempt > 0) {
+        logger21.info(`${operationName} operation succeeded after ${attempt} retries`, {
+          ...operationContext,
+          totalAttempts: attempt + 1,
+          duration: Date.now() - startTime
+        });
+      }
+      return result;
+    } catch (error) {
+      lastError = error;
+      if (specialErrorHandling) {
+        const specialResult = specialErrorHandling(error);
+        if (specialResult !== void 0) {
+          return specialResult;
+        }
+      }
+      if (attempt === retryConfig.maxRetries) {
+        break;
+      }
+      const isRetryable = shouldRetryError3(error);
+      if (!isRetryable) {
+        logger21.debug(`Not retrying ${operationName} operation due to non-retryable error`, {
+          ...operationContext,
+          errorMessage: error.message,
+          errorCode: error.code || error.status,
+          attempt: attempt + 1
+        });
+        break;
+      }
+      const delay = calculateRetryDelay3(attempt, retryConfig);
+      logger21.warning(`Retrying ${operationName} operation (attempt ${attempt + 2}) after ${delay}ms`, {
+        ...operationContext,
+        errorMessage: error.message,
+        errorCode: error.code || error.status,
+        delay,
+        attemptNumber: attempt + 1
+      });
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+  }
+  const finalError = enhanceError3(lastError, operationContext);
+  executeErrorHandler(apiOptions.errorHandler, finalError, operationContext, logger21);
+  logger21.error(`${operationName} operation failed after ${retryConfig.maxRetries + 1} attempts`, {
+    ...operationContext,
+    errorMessage: finalError.message,
+    errorCode: finalError.code || finalError.status,
+    duration: Date.now() - startTime,
+    totalAttempts: retryConfig.maxRetries + 1
+  });
+  throw finalError;
+}
+
+// src/http/HttpWrapper.ts
+var logger20 = {
+  debug: (message, context) => console.debug(message, context),
+  info: (message, context) => console.info(message, context),
+  warning: (message, context) => console.warn(message, context),
+  error: (message, context) => console.error(message, context)
+};
+var DEFAULT_RETRY_CONFIG = {
+  maxRetries: 3,
+  initialDelayMs: 1e3,
+  maxDelayMs: 3e4,
+  backoffMultiplier: 2,
+  enableJitter: true,
+  shouldRetry: (error, attemptNumber) => {
+    if (attemptNumber >= 3) return false;
+    if (error.isRetryable) return true;
+    return false;
+  },
+  onRetry: (error, attemptNumber, delay) => {
+    logger20.warning(`Retrying HTTP request (attempt ${attemptNumber + 1}) after ${delay}ms`, {
+      errorCode: error.code,
+      errorMessage: error.message,
+      delay,
+      attemptNumber
+    });
+  }
+};
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function calculateDelay(attemptNumber, config) {
+  const exponentialDelay = config.initialDelayMs * Math.pow(config.backoffMultiplier, attemptNumber);
+  const cappedDelay = Math.min(exponentialDelay, config.maxDelayMs);
+  if (!config.enableJitter) {
+    return cappedDelay;
+  }
+  const jitter = 0.5 + Math.random() * 0.5;
+  return Math.floor(cappedDelay * jitter);
+}
+var HttpWrapper = class {
+  api;
+  retryConfig;
+  constructor(api, retryConfig = {}) {
+    this.api = api;
+    this.retryConfig = { ...DEFAULT_RETRY_CONFIG, ...retryConfig };
+  }
+  /**
+   * Execute HTTP operation with retry logic and error handling
+   */
+  async executeWithRetry(operation, operationName, context) {
+    let lastError = null;
+    const startTime = Date.now();
+    for (let attempt = 0; attempt <= this.retryConfig.maxRetries; attempt++) {
+      try {
+        logger20.debug(`Executing ${operationName}`, {
+          attempt: attempt + 1,
+          maxRetries: this.retryConfig.maxRetries + 1,
+          ...context
+        });
+        const result = await operation();
+        if (attempt > 0) {
+          logger20.info(`${operationName} succeeded after ${attempt} retries`, {
+            totalAttempts: attempt + 1,
+            duration: Date.now() - startTime,
+            ...context
+          });
+        }
+        return result;
+      } catch (error) {
+        lastError = this.convertToClientApiError(error, operationName, context);
+        if (attempt === this.retryConfig.maxRetries) {
+          break;
+        }
+        if (!this.retryConfig.shouldRetry(lastError, attempt)) {
+          logger20.debug(`Not retrying ${operationName} due to non-retryable error`, {
+            errorCode: lastError.code,
+            errorMessage: lastError.message,
+            attempt: attempt + 1,
+            ...context
+          });
+          break;
+        }
+        let delay = calculateDelay(attempt, this.retryConfig);
+        if (lastError instanceof RateLimitError && lastError.retryAfter) {
+          delay = Math.max(delay, lastError.retryAfter * 1e3);
+        }
+        this.retryConfig.onRetry(lastError, attempt, delay);
+        await sleep(delay);
+      }
+    }
+    logger20.error(`${operationName} failed after ${this.retryConfig.maxRetries + 1} attempts`, {
+      errorCode: lastError?.code,
+      errorMessage: lastError?.message,
+      duration: Date.now() - startTime,
+      ...context
+    });
+    throw lastError;
+  }
+  /**
+   * Convert any error to a ClientApiError
+   */
+  convertToClientApiError(error, operationName, context) {
+    const errorContext = { operation: operationName, ...context };
+    if (error instanceof ClientApiError) {
+      return error;
+    }
+    if (error.response) {
+      const { status, statusText, data, headers } = error.response;
+      return createHttpError(status, statusText, data, {
+        ...errorContext,
+        headers,
+        url: error.config?.url
+      });
+    }
+    if (error.request) {
+      return createNetworkError(error, {
+        ...errorContext,
+        url: error.config?.url,
+        method: error.config?.method
+      });
+    }
+    return createNetworkError(error, errorContext);
+  }
+  /**
+   * Wrapper for HTTP GET operations
+   */
+  async get(url, options, context) {
+    return this.executeWithRetry(
+      () => this.api.httpGet(url, options),
+      "GET",
+      { url, ...context }
+    );
+  }
+  /**
+   * Wrapper for HTTP POST operations
+   */
+  async post(url, data, options, context) {
+    return this.executeWithRetry(
+      () => this.api.httpPost(url, data, options),
+      "POST",
+      { url, hasData: !!data, ...context }
+    );
+  }
+  /**
+   * Wrapper for HTTP PUT operations
+   */
+  async put(url, data, options, context) {
+    return this.executeWithRetry(
+      () => this.api.httpPut(url, data, options),
+      "PUT",
+      { url, hasData: !!data, ...context }
+    );
+  }
+  /**
+   * Wrapper for HTTP DELETE operations
+   */
+  async delete(url, options, context) {
+    return this.executeWithRetry(
+      () => this.api.httpDelete(url, options),
+      "DELETE",
+      { url, ...context }
+    );
+  }
+  /**
+   * Update retry configuration
+   */
+  updateRetryConfig(newConfig) {
+    Object.assign(this.retryConfig, newConfig);
+  }
+  /**
+   * Get current retry configuration
+   */
+  getRetryConfig() {
+    return { ...this.retryConfig };
+  }
+};
 export {
+  AuthenticationError,
+  AuthorizationError,
+  ClientApiError,
+  ConfigurationError,
+  ConflictError,
+  HttpError,
+  HttpWrapper,
+  NetworkError,
+  NotFoundError,
+  ParseError,
+  PayloadTooLargeError,
+  RateLimitError,
+  ServerError,
+  TimeoutError,
+  ValidationError,
+  calculateRetryDelay3 as calculateRetryDelay,
   createCItemApi,
+  createHttpError,
   createInstance,
   createInstanceFactory,
+  createNetworkError,
   createPItemApi,
   createRegistry,
-  createRegistryFactory
+  createRegistryFactory,
+  enhanceError3 as enhanceError,
+  executeErrorHandler,
+  executeWithRetry,
+  getRetryConfig,
+  isClientApiError,
+  isRetryableError,
+  shouldRetryError3 as shouldRetryError
 };
 //# sourceMappingURL=index.js.map