accessio 1.0.0

package/cjs/helpers/transformData.cjs

@@ -0,0 +1,57 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var transformData_exports = {};
+__export(transformData_exports, {
+  default: () => transformData
+});
+module.exports = __toCommonJS(transformData_exports);
+var import_accessioError = __toESM(require("../core/accessioError"), 1);
+function transformData(transforms, data, headers, config) {
+  if (!transforms || !Array.isArray(transforms)) {
+    return data;
+  }
+  let result = data;
+  for (const transform of transforms) {
+    if (typeof transform === "function") {
+      try {
+        result = transform(result, headers);
+      } catch (err) {
+        throw import_accessioError.default.from(
+          err instanceof Error ? err : new Error(String(err)),
+          import_accessioError.default.ERR_BAD_REQUEST,
+          config ?? null,
+          null,
+          null
+        );
+      }
+    }
+  }
+  return result;
+}
+//# sourceMappingURL=transformData.cjs.map

package/cjs/helpers/transformData.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/helpers/transformData.ts"],"sourcesContent":["import AccessioError from '../core/accessioError';\nimport type {\n  TransformFunction,\n  AccessioRequestConfig,\n} from '../types';\n\nexport default function transformData(\n  transforms: TransformFunction | TransformFunction[] | undefined,\n  data: unknown,\n  headers: Record<string, string>,\n  config?: AccessioRequestConfig,\n): unknown {\n  if (!transforms || !Array.isArray(transforms)) {\n    return data;\n  }\n\n  let result = data;\n\n  for (const transform of transforms) {\n    if (typeof transform === 'function') {\n      try {\n        result = transform(result, headers);\n      } catch (err) {\n        throw AccessioError.from(\n          err instanceof Error ? err : new Error(String(err)),\n          AccessioError.ERR_BAD_REQUEST,\n          config ?? null,\n          null,\n          null,\n        );\n      }\n    }\n  }\n\n  return result;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,2BAA0B;AAMX,SAAR,cACL,YACA,MACA,SACA,QACS;AACT,MAAI,CAAC,cAAc,CAAC,MAAM,QAAQ,UAAU,GAAG;AAC7C,WAAO;AAAA,EACT;AAEA,MAAI,SAAS;AAEb,aAAW,aAAa,YAAY;AAClC,QAAI,OAAO,cAAc,YAAY;AACnC,UAAI;AACF,iBAAS,UAAU,QAAQ,OAAO;AAAA,MACpC,SAAS,KAAK;AACZ,cAAM,qBAAAA,QAAc;AAAA,UAClB,eAAe,QAAQ,MAAM,IAAI,MAAM,OAAO,GAAG,CAAC;AAAA,UAClD,qBAAAA,QAAc;AAAA,UACd,UAAU;AAAA,UACV;AAAA,UACA;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAEA,SAAO;AACT;","names":["AccessioError"]}

package/cjs/index.cjs

@@ -0,0 +1,121 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var src_exports = {};
+__export(src_exports, {
+  Accessio: () => import_accessio.default,
+  AccessioError: () => import_accessioError.default,
+  InterceptorManager: () => import_interceptorManager.default,
+  buildURL: () => import_buildURL.default,
+  createInstance: () => createInstance,
+  createRateLimiter: () => import_rateLimiter.createRateLimiter,
+  default: () => src_default,
+  logError: () => import_debug.logError,
+  logRequest: () => import_debug.logRequest,
+  logResponse: () => import_debug.logResponse,
+  mergeConfig: () => import_mergeConfig.default
+});
+module.exports = __toCommonJS(src_exports);
+var import_accessio = __toESM(require("./accessio"), 1);
+var import_defaults = __toESM(require("./defaults"), 1);
+var import_accessioError = __toESM(require("./core/accessioError"), 1);
+var import_mergeConfig = __toESM(require("./core/mergeConfig"), 1);
+var import_buildURL = __toESM(require("./core/buildURL"), 1);
+var import_interceptorManager = __toESM(require("./interceptors/interceptorManager"), 1);
+var import_rateLimiter = require("./helpers/rateLimiter");
+var import_debug = require("./helpers/debug");
+var import_errorCodes = require("./constants/errorCodes");
+const PUBLIC_METHODS = [
+  "request",
+  "getUri",
+  "get",
+  "delete",
+  "head",
+  "options",
+  "post",
+  "put",
+  "patch",
+  "postForm",
+  "putForm",
+  "patchForm"
+];
+function createInstance(defaultConfig) {
+  const context = new import_accessio.default(defaultConfig);
+  const instance = function accessio2(configOrUrl, config) {
+    return context.request(configOrUrl, config);
+  };
+  for (const key of PUBLIC_METHODS) {
+    const method = context[key];
+    if (typeof method === "function") {
+      instance[key] = method.bind(context);
+    }
+  }
+  instance.defaults = context.defaults;
+  instance.interceptors = context.interceptors;
+  instance.all = function all(promises) {
+    return Promise.all(promises);
+  };
+  instance.spread = function spread(callback) {
+    return function wrap(arr) {
+      return callback(...arr);
+    };
+  };
+  instance.isCancel = function isCancel(value) {
+    return !!(value && value.isAccessioError && value.code === import_errorCodes.ERR_CANCELED);
+  };
+  instance.isAccessioError = function isAccessioError(value) {
+    return value instanceof import_accessioError.default || !!(value && typeof value === "object" && value.isAccessioError === true);
+  };
+  instance.AccessioError = import_accessioError.default;
+  instance.Accessio = import_accessio.default;
+  instance.mergeConfig = import_mergeConfig.default;
+  instance.buildURL = import_buildURL.default;
+  instance.InterceptorManager = import_interceptorManager.default;
+  instance.createRateLimiter = import_rateLimiter.createRateLimiter;
+  return instance;
+}
+const accessio = createInstance(import_defaults.default);
+function create(instanceConfig) {
+  return createInstance((0, import_mergeConfig.default)(import_defaults.default, instanceConfig));
+}
+accessio.create = create;
+var src_default = accessio;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Accessio,
+  AccessioError,
+  InterceptorManager,
+  buildURL,
+  createInstance,
+  createRateLimiter,
+  logError,
+  logRequest,
+  logResponse,
+  mergeConfig
+});
+//# sourceMappingURL=index.cjs.map

package/cjs/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import Accessio from './accessio';\nimport defaults from './defaults';\nimport AccessioError from './core/accessioError';\nimport mergeConfig from './core/mergeConfig';\nimport buildURL from './core/buildURL';\nimport InterceptorManager from './interceptors/interceptorManager';\nimport { createRateLimiter } from './helpers/rateLimiter';\nimport { logRequest, logResponse, logError } from './helpers/debug';\nimport { ERR_CANCELED } from './constants/errorCodes';\nimport type { AccessioRequestConfig, AccessioResponse } from './types';\n\nconst PUBLIC_METHODS = [\n  'request',\n  'getUri',\n  'get',\n  'delete',\n  'head',\n  'options',\n  'post',\n  'put',\n  'patch',\n  'postForm',\n  'putForm',\n  'patchForm',\n];\n\nfunction createInstance(defaultConfig: AccessioRequestConfig) {\n  const context = new Accessio(defaultConfig);\n\n  const instance: any = function accessio(\n    configOrUrl: string | AccessioRequestConfig,\n    config?: AccessioRequestConfig,\n  ) {\n    return context.request(configOrUrl, config);\n  };\n\n  for (const key of PUBLIC_METHODS) {\n    const method: any = (context as any)[key];\n    if (typeof method === 'function') {\n      instance[key] = method.bind(context);\n    }\n  }\n\n  instance.defaults = context.defaults;\n  instance.interceptors = context.interceptors;\n  instance.all = function all(promises: any[]): Promise<any[]> {\n    return Promise.all(promises);\n  };\n  instance.spread = function spread<T>(\n    callback: (...args: any[]) => T,\n  ): (arr: any[]) => T {\n    return function wrap(arr: any[]): T {\n      return callback(...arr);\n    };\n  };\n  instance.isCancel = function isCancel(value: any): boolean {\n    return !!(\n      value &&\n      value.isAccessioError &&\n      value.code === ERR_CANCELED\n    );\n  };\n  instance.isAccessioError = function isAccessioError(\n    value: any,\n  ): boolean {\n    return (\n      value instanceof AccessioError ||\n      !!(value && typeof value === 'object' && value.isAccessioError === true)\n    );\n  };\n  instance.AccessioError = AccessioError;\n  instance.Accessio = Accessio;\n  instance.mergeConfig = mergeConfig;\n  instance.buildURL = buildURL;\n  instance.InterceptorManager = InterceptorManager;\n  instance.createRateLimiter = createRateLimiter;\n\n  return instance;\n}\n\nconst accessio = createInstance(defaults);\n\nfunction create(instanceConfig?: AccessioRequestConfig) {\n  return createInstance(mergeConfig(defaults, instanceConfig));\n}\n\naccessio.create = create;\n\nexport default accessio;\n\nexport {\n  Accessio,\n  AccessioError,\n  mergeConfig,\n  buildURL,\n  InterceptorManager,\n  createInstance,\n  createRateLimiter,\n  logRequest,\n  logResponse,\n  logError,\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA,kCAAAA;AAAA,EAAA,0CAAAC;AAAA,EAAA,oDAAAC;AAAA,EAAA,gCAAAC;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,wCAAAC;AAAA;AAAA;AAAA,sBAAqB;AACrB,sBAAqB;AACrB,2BAA0B;AAC1B,yBAAwB;AACxB,sBAAqB;AACrB,gCAA+B;AAC/B,yBAAkC;AAClC,mBAAkD;AAClD,wBAA6B;AAG7B,MAAM,iBAAiB;AAAA,EACrB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;AAEA,SAAS,eAAe,eAAsC;AAC5D,QAAM,UAAU,IAAI,gBAAAJ,QAAS,aAAa;AAE1C,QAAM,WAAgB,SAASK,UAC7B,aACA,QACA;AACA,WAAO,QAAQ,QAAQ,aAAa,MAAM;AAAA,EAC5C;AAEA,aAAW,OAAO,gBAAgB;AAChC,UAAM,SAAe,QAAgB,GAAG;AACxC,QAAI,OAAO,WAAW,YAAY;AAChC,eAAS,GAAG,IAAI,OAAO,KAAK,OAAO;AAAA,IACrC;AAAA,EACF;AAEA,WAAS,WAAW,QAAQ;AAC5B,WAAS,eAAe,QAAQ;AAChC,WAAS,MAAM,SAAS,IAAI,UAAiC;AAC3D,WAAO,QAAQ,IAAI,QAAQ;AAAA,EAC7B;AACA,WAAS,SAAS,SAAS,OACzB,UACmB;AACnB,WAAO,SAAS,KAAK,KAAe;AAClC,aAAO,SAAS,GAAG,GAAG;AAAA,IACxB;AAAA,EACF;AACA,WAAS,WAAW,SAAS,SAAS,OAAqB;AACzD,WAAO,CAAC,EACN,SACA,MAAM,mBACN,MAAM,SAAS;AAAA,EAEnB;AACA,WAAS,kBAAkB,SAAS,gBAClC,OACS;AACT,WACE,iBAAiB,qBAAAJ,WACjB,CAAC,EAAE,SAAS,OAAO,UAAU,YAAY,MAAM,oBAAoB;AAAA,EAEvE;AACA,WAAS,gBAAgB,qBAAAA;AACzB,WAAS,WAAW,gBAAAD;AACpB,WAAS,cAAc,mBAAAI;AACvB,WAAS,WAAW,gBAAAD;AACpB,WAAS,qBAAqB,0BAAAD;AAC9B,WAAS,oBAAoB;AAE7B,SAAO;AACT;AAEA,MAAM,WAAW,eAAe,gBAAAI,OAAQ;AAExC,SAAS,OAAO,gBAAwC;AACtD,SAAO,mBAAe,mBAAAF,SAAY,gBAAAE,SAAU,cAAc,CAAC;AAC7D;AAEA,SAAS,SAAS;AAElB,IAAO,cAAQ;","names":["Accessio","AccessioError","InterceptorManager","buildURL","mergeConfig","accessio","defaults"]}

package/cjs/interceptors/interceptorManager.cjs

@@ -0,0 +1,31 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var interceptorManager_exports = {};
+__export(interceptorManager_exports, {
+  InterceptorManager: () => import_types.InterceptorManager,
+  default: () => interceptorManager_default
+});
+module.exports = __toCommonJS(interceptorManager_exports);
+var import_types = require("../types");
+var interceptorManager_default = import_types.InterceptorManager;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InterceptorManager
+});
+//# sourceMappingURL=interceptorManager.cjs.map

package/cjs/interceptors/interceptorManager.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/interceptors/interceptorManager.ts"],"sourcesContent":["import { InterceptorManager } from '../types';\n\nexport { InterceptorManager };\n\nexport default InterceptorManager;\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAAmC;AAInC,IAAO,6BAAQ;","names":[]}

package/index.d.ts

@@ -0,0 +1,454 @@
+/**
+ * Accessio HTTP Client — TypeScript Type Definitions
+ */
+
+/**
+ * Avoids ambiguous intersection of Record<string, string> & { common?, get?, ... }
+ * which TypeScript accepts but can confuse type consumers.
+ */
+export type AccessioHeaders = {
+  common?: Record<string, string>;
+  get?: Record<string, string>;
+  post?: Record<string, string>;
+  put?: Record<string, string>;
+  patch?: Record<string, string>;
+  delete?: Record<string, string>;
+  head?: Record<string, string>;
+  options?: Record<string, string>;
+  /** Any additional custom headers */
+  [key: string]: string | number | boolean | Record<string, string> | undefined;
+};
+
+export interface AccessioRequestConfig {
+  /** Request URL (path or full URL) */
+  url?: string;
+
+  /** HTTP method (default: 'get') */
+  method?:
+    | "get"
+    | "post"
+    | "put"
+    | "patch"
+    | "delete"
+    | "head"
+    | "options"
+    | string;
+
+  /** Base URL prepended to `url` unless `url` is absolute */
+  baseURL?: string;
+
+  /** Request headers */
+  headers?: AccessioHeaders;
+
+  /** URL query parameters */
+  params?: Record<string, any>;
+
+  /** Custom params serializer function */
+  paramsSerializer?: (params: Record<string, any>) => string;
+
+  /** Request body data */
+  data?: any;
+
+  /** Timeout in milliseconds (0 = no timeout) */
+  timeout?: number;
+
+  /** Include credentials in cross-site requests */
+  withCredentials?: boolean;
+
+  /** Expected response data type */
+  responseType?: "json" | "text" | "blob" | "arraybuffer" | "stream";
+
+  /** Transform functions applied to request data */
+  transformRequest?: Array<
+    (data: any, headers?: Record<string, string>) => any
+  >;
+
+  /** Transform functions applied to response data */
+  transformResponse?: Array<
+    (data: any, headers?: Record<string, string>) => any
+  >;
+
+  /** Function to determine if a status code should resolve or reject */
+  validateStatus?: (status: number) => boolean;
+
+  /** AbortSignal for request cancellation */
+  signal?: AbortSignal;
+
+  /** Basic auth credentials */
+  auth?: {
+    username: string;
+    password: string;
+  };
+
+  // ── Retry options ──────────────────────────────────
+
+  /** Maximum number of retry attempts (0 = no retries, default: 0) */
+  retry?: number;
+
+  /** Base delay in milliseconds for retry backoff (default: 1000) */
+  retryDelay?: number;
+
+  /** Custom condition to decide whether to retry a failed request */
+  retryCondition?: (error: AccessioError) => boolean;
+
+  /** Callback invoked before each retry attempt */
+  onRetry?: (
+    attempt: number,
+    error: AccessioError,
+    config: AccessioRequestConfig,
+  ) => void;
+
+  // ── Debug ──────────────────────────────────────────
+
+  /** Enable debug logging for this request */
+  debug?: boolean;
+
+  // ── Rate Limiting ──────────────────────────────────
+
+  /** Rate limiter instance to control concurrent requests */
+  rateLimiter?: RateLimiter;
+
+  /** Allow any additional custom properties */
+  [key: string]: any;
+}
+
+export interface AccessioResponse<T = any> {
+  /** Response data (parsed) */
+  data: T;
+
+  /** HTTP status code */
+  status: number;
+
+  /** HTTP status text */
+  statusText: string;
+
+  /** Response headers (lowercased keys) */
+  headers: Record<string, string>;
+
+  /** The config used for this request */
+  config: AccessioRequestConfig;
+
+  /** The underlying request object */
+  request: any;
+
+  /** Request duration in milliseconds */
+  duration: number;
+}
+
+// ── Class type definitions ────────────────────────────────────
+
+export interface AccessioClass {
+  new (instanceConfig?: AccessioRequestConfig): {
+    defaults: AccessioRequestConfig;
+    interceptors: {
+      request: InterceptorManager<AccessioRequestConfig>;
+      response: InterceptorManager<AccessioResponse>;
+    };
+    request<T = any>(config: AccessioRequestConfig): Promise<AccessioResponse<T>>;
+    request<T = any>(url: string, config?: AccessioRequestConfig): Promise<AccessioResponse<T>>;
+    get<T = any>(url: string, config?: AccessioRequestConfig): Promise<AccessioResponse<T>>;
+    delete<T = any>(url: string, config?: AccessioRequestConfig): Promise<AccessioResponse<T>>;
+    head<T = any>(url: string, config?: AccessioRequestConfig): Promise<AccessioResponse<T>>;
+    options<T = any>(url: string, config?: AccessioRequestConfig): Promise<AccessioResponse<T>>;
+    post<T = any>(url: string, data?: any, config?: AccessioRequestConfig): Promise<AccessioResponse<T>>;
+    put<T = any>(url: string, data?: any, config?: AccessioRequestConfig): Promise<AccessioResponse<T>>;
+    patch<T = any>(url: string, data?: any, config?: AccessioRequestConfig): Promise<AccessioResponse<T>>;
+    postForm<T = any>(url: string, data?: any, config?: AccessioRequestConfig): Promise<AccessioResponse<T>>;
+    putForm<T = any>(url: string, data?: any, config?: AccessioRequestConfig): Promise<AccessioResponse<T>>;
+    patchForm<T = any>(url: string, data?: any, config?: AccessioRequestConfig): Promise<AccessioResponse<T>>;
+    getUri(config: AccessioRequestConfig): string;
+  };
+}
+
+export interface InterceptorManagerClass {
+  new <V>(): InterceptorManager<V>;
+}
+
+export interface AccessioError<T = any> extends Error {
+  /** Error name (always 'AccessioError') */
+  name: "AccessioError";
+
+  /** Error message */
+  message: string;
+
+  /** Error code (e.g. 'ECONNABORTED', 'ERR_NETWORK') */
+  code: string | null;
+
+  /** The config used for this request */
+  config: AccessioRequestConfig | null;
+
+  /** The underlying request object */
+  request: any | null;
+
+  /** The response object (if available) */
+  response: AccessioResponse<T> | null;
+
+  /** Accessio error flag */
+  isAccessioError: boolean;
+
+  /** Original error that caused this AccessioError (set by AccessioError.from()) */
+  cause?: Error;
+
+  /** JSON representation */
+  toJSON(): object;
+}
+
+export interface AccessioErrorConstructor {
+  new (
+    message: string,
+    code?: string,
+    config?: AccessioRequestConfig,
+    request?: any,
+    response?: AccessioResponse,
+  ): AccessioError;
+
+  /** Create an AccessioError from an existing Error */
+  from(
+    error: Error,
+    code?: string,
+    config?: AccessioRequestConfig,
+    request?: any,
+    response?: AccessioResponse,
+  ): AccessioError;
+
+  // Error code constants
+  ERR_BAD_OPTION_VALUE: string;
+  ERR_BAD_OPTION: string;
+  ECONNABORTED: string;
+  ETIMEDOUT: string;
+  ERR_NETWORK: string;
+  ERR_FR_TOO_MANY_REDIRECTS: string;
+  ERR_BAD_RESPONSE: string;
+  ERR_BAD_REQUEST: string;
+  ERR_CANCELED: string;
+  ERR_NOT_SUPPORT: string;
+  ERR_INVALID_URL: string;
+}
+
+export interface InterceptorManager<V> {
+  /**
+   * Register a new interceptor.
+   * @returns Interceptor ID for eject()
+   */
+  use(
+    onFulfilled?: ((value: V) => V | Promise<V>) | null,
+    onRejected?: ((error: any) => V | Promise<V>) | null,
+    options?: {
+      synchronous?: boolean;
+      runWhen?: (config: AccessioRequestConfig) => boolean;
+    },
+  ): number;
+
+  /** Remove an interceptor by its ID */
+  eject(id: number): void;
+
+  /** Remove all interceptors */
+  clear(): void;
+
+  /** Number of active (non-ejected) interceptors */
+  readonly size: number;
+}
+
+/** Rate limiter instance returned by createRateLimiter() */
+export interface RateLimiter {
+  /** Acquire a slot. Resolves immediately if available, otherwise queues. */
+  acquire(): Promise<void>;
+
+  /** Release a slot. Starts the next queued request if any. */
+  release(): void;
+
+  /**
+   * Destroy the limiter — rejects all pending queued promises immediately.
+   * Any subsequent acquire() calls will also reject.
+   * Useful for cleanup on SPA navigation or component unmount.
+   */
+  destroy(): void;
+
+  /** Number of requests waiting in the queue */
+  readonly pending: number;
+
+  /** Number of currently active requests */
+  readonly active: number;
+
+  /** Whether the limiter has been destroyed */
+  readonly destroyed: boolean;
+}
+
+export interface AccessioInstance {
+  /** Execute a request with a full config object */
+  (config: AccessioRequestConfig): Promise<AccessioResponse>;
+
+  /** Execute a request with URL + optional config */
+  (url: string, config?: AccessioRequestConfig): Promise<AccessioResponse>;
+
+  /** Instance defaults (mutable) */
+  defaults: AccessioRequestConfig;
+
+  /** Request and response interceptors */
+  interceptors: {
+    request: InterceptorManager<AccessioRequestConfig>;
+    response: InterceptorManager<AccessioResponse>;
+  };
+
+  /** Core request method */
+  request<T = any>(config: AccessioRequestConfig): Promise<AccessioResponse<T>>;
+  request<T = any>(
+    url: string,
+    config?: AccessioRequestConfig,
+  ): Promise<AccessioResponse<T>>;
+
+  /** GET request */
+  get<T = any>(
+    url: string,
+    config?: AccessioRequestConfig,
+  ): Promise<AccessioResponse<T>>;
+
+  /** DELETE request */
+  delete<T = any>(
+    url: string,
+    config?: AccessioRequestConfig,
+  ): Promise<AccessioResponse<T>>;
+
+  /** HEAD request */
+  head<T = any>(
+    url: string,
+    config?: AccessioRequestConfig,
+  ): Promise<AccessioResponse<T>>;
+
+  /** OPTIONS request */
+  options<T = any>(
+    url: string,
+    config?: AccessioRequestConfig,
+  ): Promise<AccessioResponse<T>>;
+
+  /** POST request */
+  post<T = any>(
+    url: string,
+    data?: any,
+    config?: AccessioRequestConfig,
+  ): Promise<AccessioResponse<T>>;
+
+  /** PUT request */
+  put<T = any>(
+    url: string,
+    data?: any,
+    config?: AccessioRequestConfig,
+  ): Promise<AccessioResponse<T>>;
+
+  /** PATCH request */
+  patch<T = any>(
+    url: string,
+    data?: any,
+    config?: AccessioRequestConfig,
+  ): Promise<AccessioResponse<T>>;
+
+  /** POST with multipart/form-data */
+  postForm<T = any>(
+    url: string,
+    data?: any,
+    config?: AccessioRequestConfig,
+  ): Promise<AccessioResponse<T>>;
+
+  /** PUT with multipart/form-data */
+  putForm<T = any>(
+    url: string,
+    data?: any,
+    config?: AccessioRequestConfig,
+  ): Promise<AccessioResponse<T>>;
+
+  /** PATCH with multipart/form-data */
+  patchForm<T = any>(
+    url: string,
+    data?: any,
+    config?: AccessioRequestConfig,
+  ): Promise<AccessioResponse<T>>;
+
+  /** Get the built URL for a given config */
+  getUri(config: AccessioRequestConfig): string;
+
+  /** Create a new Accessio instance with custom defaults */
+  create(instanceConfig?: AccessioRequestConfig): AccessioInstance;
+
+  /** Execute multiple concurrent requests */
+  all<T>(values: Array<T | Promise<T>>): Promise<T[]>;
+
+  /** Spread array of responses to individual callback arguments */
+  spread<T, R>(callback: (...args: T[]) => R): (array: T[]) => R;
+
+  /** Check if an error is a cancellation error */
+  isCancel(value: any): boolean;
+
+  /** Check if a value is a AccessioError */
+  isAccessioError(value: any): boolean;
+
+  /** AccessioError class */
+  AccessioError: AccessioErrorConstructor;
+
+  /** Accessio class */
+  Accessio: AccessioClass;
+
+  /** InterceptorManager class */
+  InterceptorManager: InterceptorManagerClass;
+
+  /** Create a rate limiter for concurrent request control */
+  createRateLimiter(maxConcurrent?: number): RateLimiter;
+
+  /** Merge two config objects */
+  mergeConfig(
+    config1: AccessioRequestConfig,
+    config2?: AccessioRequestConfig,
+  ): AccessioRequestConfig;
+
+  /** Build a URL from parts */
+  buildURL(
+    url: string,
+    baseURL?: string,
+    params?: Record<string, any>,
+    paramsSerializer?: (params: Record<string, any>) => string,
+  ): string;
+}
+
+/** Default Accessio instance */
+declare const accessio: AccessioInstance;
+export default accessio;
+
+// ── Named exports ─────────────────────────────────────────────
+// Note: These are re-exported for convenience. The actual implementations
+// are in src/, but TypeScript resolves these through package.json exports.
+
+export interface Accessio {
+  defaults: AccessioRequestConfig;
+  interceptors: {
+    request: InterceptorManager<AccessioRequestConfig>;
+    response: InterceptorManager<AccessioResponse>;
+  };
+  request<T = any>(config: AccessioRequestConfig): Promise<AccessioResponse<T>>;
+  request<T = any>(url: string, config?: AccessioRequestConfig): Promise<AccessioResponse<T>>;
+  get<T = any>(url: string, config?: AccessioRequestConfig): Promise<AccessioResponse<T>>;
+  delete<T = any>(url: string, config?: AccessioRequestConfig): Promise<AccessioResponse<T>>;
+  head<T = any>(url: string, config?: AccessioRequestConfig): Promise<AccessioResponse<T>>;
+  options<T = any>(url: string, config?: AccessioRequestConfig): Promise<AccessioResponse<T>>;
+  post<T = any>(url: string, data?: any, config?: AccessioRequestConfig): Promise<AccessioResponse<T>>;
+  put<T = any>(url: string, data?: any, config?: AccessioRequestConfig): Promise<AccessioResponse<T>>;
+  patch<T = any>(url: string, data?: any, config?: AccessioRequestConfig): Promise<AccessioResponse<T>>;
+  postForm<T = any>(url: string, data?: any, config?: AccessioRequestConfig): Promise<AccessioResponse<T>>;
+  putForm<T = any>(url: string, data?: any, config?: AccessioRequestConfig): Promise<AccessioResponse<T>>;
+  patchForm<T = any>(url: string, data?: any, config?: AccessioRequestConfig): Promise<AccessioResponse<T>>;
+  getUri(config: AccessioRequestConfig): string;
+}
+
+export declare const Accessio: {
+  new (instanceConfig?: AccessioRequestConfig): Accessio;
+};
+
+export const AccessioError: AccessioErrorConstructor;
+export const mergeConfig: (config1: AccessioRequestConfig, config2?: AccessioRequestConfig) => AccessioRequestConfig;
+export const buildURL: (url: string, baseURL?: string, params?: Record<string, any>, paramsSerializer?: (params: Record<string, any>) => string) => string;
+export const InterceptorManager: InterceptorManagerClass;
+export const createRateLimiter: (maxConcurrent?: number) => RateLimiter;
+
+// ── Debug helper exports ────────────────────────────────────
+
+export function logRequest(config: AccessioRequestConfig, fullUrl: string): void;
+export function logResponse(response: AccessioResponse): void;
+export function logError(error: Error, config?: AccessioRequestConfig): void;