@lgriffin/esi.ts 8.0.0 → 9.1.0

package/dist/index.js

@@ -44,6 +44,7 @@ __export(index_exports, {
   ClonesClient: () => ClonesClient,
   ContactsClient: () => ContactsClient,
   ContractsClient: () => ContractsClient,
+  CorporationProjectsClient: () => CorporationProjectsClient,
   CorporationsClient: () => CorporationsClient,
   CustomEsiClient: () => CustomEsiClient,
   DogmaClient: () => DogmaClient,
@@ -69,6 +70,7 @@ __export(index_exports, {
   MarketClient: () => MarketClient,
   MercenaryClient: () => MercenaryClient,
   MetaClient: () => MetaClient,
+  MilitaryCampaignsClient: () => MilitaryCampaignsClient,
   PiClient: () => PiClient,
   RateLimiter: () => RateLimiter,
   RequestDeduplicator: () => RequestDeduplicator,
@@ -92,6 +94,7 @@ __export(index_exports, {
   fetchAllCursorPages: () => fetchAllCursorPages,
   fetchPages: () => fetchPages,
   getDefaultClient: () => getDefaultClient,
+  isCircuitOpen: () => isCircuitOpen,
   isEsiError: () => isEsiError,
   isForbidden: () => isForbidden,
   isNotFound: () => isNotFound,
@@ -308,6 +311,216 @@ var ApiClient = class {
   }
 };
 
+// src/core/logger/logger.ts
+var import_pino = __toESM(require("pino"));
+var pinoLogger = (0, import_pino.default)({ level: process.env.ESI_LOG_LEVEL || "warn" });
+var logger = {
+  info: (msg) => {
+    pinoLogger.info(msg);
+  },
+  warn: (msg) => {
+    pinoLogger.warn(msg);
+  },
+  error: (msg) => {
+    pinoLogger.error(msg);
+  },
+  debug: (msg) => {
+    pinoLogger.debug(msg);
+  }
+};
+var logger_default = logger;
+
+// src/core/logger/loggerUtil.ts
+var activeLogger = logger_default;
+var setLogger = (customLogger) => {
+  activeLogger = customLogger;
+};
+var logInfo = (message) => {
+  activeLogger.info(message);
+};
+var logError = (message) => {
+  activeLogger.error(message);
+};
+var logWarn = (message) => {
+  activeLogger.warn(message);
+};
+var logDebug = (message) => {
+  activeLogger.debug(message);
+};
+
+// src/core/circuitBreaker/CircuitBreaker.ts
+var CircuitBreaker = class {
+  circuits = /* @__PURE__ */ new Map();
+  failureThreshold;
+  resetTimeoutMs;
+  halfOpenMaxAttempts;
+  staleThresholdMs;
+  keyStrategy;
+  cleanupTimer = null;
+  constructor(config = {}) {
+    this.failureThreshold = config.failureThreshold ?? 5;
+    this.resetTimeoutMs = config.resetTimeoutMs ?? 3e4;
+    this.halfOpenMaxAttempts = config.halfOpenMaxAttempts ?? 1;
+    this.staleThresholdMs = config.staleThresholdMs ?? 36e5;
+    this.keyStrategy = config.keyStrategy ?? "resolved";
+    const cleanupIntervalMs = config.cleanupIntervalMs;
+    if (cleanupIntervalMs !== void 0 && cleanupIntervalMs > 0) {
+      this.startCleanupTimer(cleanupIntervalMs);
+    }
+  }
+  getKey(endpoint) {
+    return endpoint.split("?")[0];
+  }
+  getOrCreate(key) {
+    let record = this.circuits.get(key);
+    if (!record) {
+      record = {
+        state: "closed",
+        failures: 0,
+        lastFailureTime: 0,
+        halfOpenAttempts: 0
+      };
+      this.circuits.set(key, record);
+    }
+    return record;
+  }
+  checkCircuit(endpoint) {
+    const key = this.getKey(endpoint);
+    const record = this.getOrCreate(key);
+    if (record.state === "closed") return;
+    if (record.state === "open") {
+      const elapsed = Date.now() - record.lastFailureTime;
+      if (elapsed >= this.resetTimeoutMs) {
+        record.state = "half-open";
+        record.halfOpenAttempts = 0;
+        logInfo(`Circuit half-open for ${key}, allowing probe request`);
+        return;
+      }
+      const remainingMs = this.resetTimeoutMs - elapsed;
+      throw new CircuitOpenError(key, record.failures, remainingMs);
+    }
+    if (record.state === "half-open") {
+      if (record.halfOpenAttempts >= this.halfOpenMaxAttempts) {
+        throw new CircuitOpenError(key, record.failures, this.resetTimeoutMs);
+      }
+      record.halfOpenAttempts++;
+    }
+  }
+  recordSuccess(endpoint) {
+    const key = this.getKey(endpoint);
+    const record = this.circuits.get(key);
+    if (!record) return;
+    if (record.state === "half-open") {
+      logInfo(`Circuit closed for ${key} after successful probe`);
+    }
+    record.state = "closed";
+    record.failures = 0;
+    record.halfOpenAttempts = 0;
+  }
+  recordFailure(endpoint, statusCode) {
+    if (statusCode !== 0 && statusCode < 500 && statusCode !== 420 && statusCode !== 429) {
+      return;
+    }
+    const key = this.getKey(endpoint);
+    const record = this.getOrCreate(key);
+    record.failures++;
+    record.lastFailureTime = Date.now();
+    if (record.state === "half-open") {
+      record.state = "open";
+      logWarn(
+        `Circuit re-opened for ${key} after failed probe (${record.failures} failures)`
+      );
+      return;
+    }
+    if (record.failures >= this.failureThreshold) {
+      record.state = "open";
+      logWarn(
+        `Circuit opened for ${key} after ${record.failures} consecutive failures`
+      );
+    }
+  }
+  getState(endpoint) {
+    const key = this.getKey(endpoint);
+    const record = this.circuits.get(key);
+    if (!record) return "closed";
+    if (record.state === "open") {
+      const elapsed = Date.now() - record.lastFailureTime;
+      if (elapsed >= this.resetTimeoutMs) {
+        return "half-open";
+      }
+    }
+    return record.state;
+  }
+  getStats() {
+    const circuits = {};
+    let openCircuits = 0;
+    for (const [key, record] of this.circuits.entries()) {
+      const state = this.getState(key);
+      circuits[key] = { state, failures: record.failures };
+      if (state === "open") openCircuits++;
+    }
+    return {
+      totalCircuits: this.circuits.size,
+      openCircuits,
+      circuits
+    };
+  }
+  reset(endpoint) {
+    if (endpoint) {
+      this.circuits.delete(this.getKey(endpoint));
+    } else {
+      this.circuits.clear();
+    }
+  }
+  cleanup() {
+    const now = Date.now();
+    let cleaned = 0;
+    for (const [key, record] of this.circuits.entries()) {
+      if (record.state === "closed" && record.failures === 0 && record.lastFailureTime > 0 && now - record.lastFailureTime > this.staleThresholdMs) {
+        this.circuits.delete(key);
+        cleaned++;
+      }
+    }
+    if (cleaned > 0) {
+      logInfo(`Circuit breaker cleanup: removed ${cleaned} stale circuits`);
+    }
+    return cleaned;
+  }
+  getKeyStrategy() {
+    return this.keyStrategy;
+  }
+  destroy() {
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+      this.cleanupTimer = null;
+    }
+    this.circuits.clear();
+  }
+  shutdown() {
+    this.destroy();
+  }
+  startCleanupTimer(intervalMs) {
+    this.cleanupTimer = setInterval(() => {
+      this.cleanup();
+    }, intervalMs);
+    this.cleanupTimer.unref();
+  }
+};
+var CircuitOpenError = class extends Error {
+  endpoint;
+  failures;
+  retryAfterMs;
+  constructor(endpoint, failures, retryAfterMs) {
+    super(
+      `Circuit breaker open for ${endpoint} after ${failures} failures (retry after ${Math.ceil(retryAfterMs / 1e3)}s)`
+    );
+    this.name = "CircuitOpenError";
+    this.endpoint = endpoint;
+    this.failures = failures;
+    this.retryAfterMs = retryAfterMs;
+  }
+};
+
 // src/core/util/error.ts
 var SENSITIVE_PARAMS = [
   "token",
@@ -402,6 +615,9 @@ function isTimeout(error) {
 function isRetryable(error) {
   return error instanceof EsiError && error.retryable;
 }
+function isCircuitOpen(error) {
+  return error instanceof CircuitOpenError;
+}
 var buildError = (message, type = "ERROR", url) => {
   const error = new Error(`[${type}] ${message}`);
   if (url) {
@@ -425,46 +641,9 @@ function isValidationError(error) {
   return error instanceof EsiValidationError;
 }
 
-// src/core/logger/logger.ts
-var import_pino = __toESM(require("pino"));
-var pinoLogger = (0, import_pino.default)({ level: process.env.ESI_LOG_LEVEL || "warn" });
-var logger = {
-  info: (msg) => {
-    pinoLogger.info(msg);
-  },
-  warn: (msg) => {
-    pinoLogger.warn(msg);
-  },
-  error: (msg) => {
-    pinoLogger.error(msg);
-  },
-  debug: (msg) => {
-    pinoLogger.debug(msg);
-  }
-};
-var logger_default = logger;
-
-// src/core/logger/loggerUtil.ts
-var activeLogger = logger_default;
-var setLogger = (customLogger) => {
-  activeLogger = customLogger;
-};
-var logInfo = (message) => {
-  activeLogger.info(message);
-};
-var logError = (message) => {
-  activeLogger.error(message);
-};
-var logWarn = (message) => {
-  activeLogger.warn(message);
-};
-var logDebug = (message) => {
-  activeLogger.debug(message);
-};
-
 // src/core/constants.ts
 var PACKAGE_NAME = "esi.ts";
-var PACKAGE_VERSION = "7.4.0";
+var PACKAGE_VERSION = "9.1.0";
 var USER_AGENT = `${PACKAGE_NAME}/${PACKAGE_VERSION}`;
 var COMPATIBILITY_DATE = "2026-05-19";
 
@@ -668,6 +847,7 @@ function trySpecAwareCacheHit(client, url, method, templatePath, resolveCache2)
     return {
       headers: entry.headers,
       body: entry.data,
+      status: 200,
       fromCache: true,
       cacheHitType: "spec-ttl"
     };
@@ -682,6 +862,7 @@ function tryStaleCacheResponse(client, url, parsed, resolveCache2) {
   return {
     headers: { ...cachedEntry.headers, ...parsed.raw },
     body: cachedEntry.data,
+    status: 200,
     fromCache: true,
     stale: true,
     cacheHitType: "stale-on-error"
@@ -692,188 +873,15 @@ function cacheResponse(client, url, method, endpoint, parsed, data, useETag, res
   if (useETag && method === "GET" && cache && parsed.etag) {
     const headerTtl = parseCacheControlTtl(parsed.raw);
     const specTtlMs = templatePath ? lookupSpecTtl(method, templatePath) : void 0;
-    const ttl = specTtlMs ?? headerTtl;
-    cache.set(url, parsed.etag, data, parsed.raw, ttl);
-    const ttlInfo = ttl ? ` (ttl=${ttl}ms)` : "";
-    logDebug(`Cached response for ${url} with ETag ${parsed.etag}${ttlInfo}`);
-  }
-  if (method !== "GET" && cache) {
-    cache.deleteByPath(endpoint.split("?")[0]);
-  }
-}
-
-// src/core/circuitBreaker/CircuitBreaker.ts
-var CircuitBreaker = class {
-  circuits = /* @__PURE__ */ new Map();
-  failureThreshold;
-  resetTimeoutMs;
-  halfOpenMaxAttempts;
-  staleThresholdMs;
-  keyStrategy;
-  cleanupTimer = null;
-  constructor(config = {}) {
-    this.failureThreshold = config.failureThreshold ?? 5;
-    this.resetTimeoutMs = config.resetTimeoutMs ?? 3e4;
-    this.halfOpenMaxAttempts = config.halfOpenMaxAttempts ?? 1;
-    this.staleThresholdMs = config.staleThresholdMs ?? 36e5;
-    this.keyStrategy = config.keyStrategy ?? "resolved";
-    const cleanupIntervalMs = config.cleanupIntervalMs;
-    if (cleanupIntervalMs !== void 0 && cleanupIntervalMs > 0) {
-      this.startCleanupTimer(cleanupIntervalMs);
-    }
-  }
-  getKey(endpoint) {
-    return endpoint.split("?")[0];
-  }
-  getOrCreate(key) {
-    let record = this.circuits.get(key);
-    if (!record) {
-      record = {
-        state: "closed",
-        failures: 0,
-        lastFailureTime: 0,
-        halfOpenAttempts: 0
-      };
-      this.circuits.set(key, record);
-    }
-    return record;
-  }
-  checkCircuit(endpoint) {
-    const key = this.getKey(endpoint);
-    const record = this.getOrCreate(key);
-    if (record.state === "closed") return;
-    if (record.state === "open") {
-      const elapsed = Date.now() - record.lastFailureTime;
-      if (elapsed >= this.resetTimeoutMs) {
-        record.state = "half-open";
-        record.halfOpenAttempts = 0;
-        logInfo(`Circuit half-open for ${key}, allowing probe request`);
-        return;
-      }
-      const remainingMs = this.resetTimeoutMs - elapsed;
-      throw new CircuitOpenError(key, record.failures, remainingMs);
-    }
-    if (record.state === "half-open") {
-      if (record.halfOpenAttempts >= this.halfOpenMaxAttempts) {
-        throw new CircuitOpenError(key, record.failures, this.resetTimeoutMs);
-      }
-      record.halfOpenAttempts++;
-    }
-  }
-  recordSuccess(endpoint) {
-    const key = this.getKey(endpoint);
-    const record = this.circuits.get(key);
-    if (!record) return;
-    if (record.state === "half-open") {
-      logInfo(`Circuit closed for ${key} after successful probe`);
-    }
-    record.state = "closed";
-    record.failures = 0;
-    record.halfOpenAttempts = 0;
-  }
-  recordFailure(endpoint, statusCode) {
-    if (statusCode !== 0 && statusCode < 500 && statusCode !== 420 && statusCode !== 429) {
-      return;
-    }
-    const key = this.getKey(endpoint);
-    const record = this.getOrCreate(key);
-    record.failures++;
-    record.lastFailureTime = Date.now();
-    if (record.state === "half-open") {
-      record.state = "open";
-      logWarn(
-        `Circuit re-opened for ${key} after failed probe (${record.failures} failures)`
-      );
-      return;
-    }
-    if (record.failures >= this.failureThreshold) {
-      record.state = "open";
-      logWarn(
-        `Circuit opened for ${key} after ${record.failures} consecutive failures`
-      );
-    }
-  }
-  getState(endpoint) {
-    const key = this.getKey(endpoint);
-    const record = this.circuits.get(key);
-    if (!record) return "closed";
-    if (record.state === "open") {
-      const elapsed = Date.now() - record.lastFailureTime;
-      if (elapsed >= this.resetTimeoutMs) {
-        return "half-open";
-      }
-    }
-    return record.state;
-  }
-  getStats() {
-    const circuits = {};
-    let openCircuits = 0;
-    for (const [key, record] of this.circuits.entries()) {
-      const state = this.getState(key);
-      circuits[key] = { state, failures: record.failures };
-      if (state === "open") openCircuits++;
-    }
-    return {
-      totalCircuits: this.circuits.size,
-      openCircuits,
-      circuits
-    };
-  }
-  reset(endpoint) {
-    if (endpoint) {
-      this.circuits.delete(this.getKey(endpoint));
-    } else {
-      this.circuits.clear();
-    }
-  }
-  cleanup() {
-    const now = Date.now();
-    let cleaned = 0;
-    for (const [key, record] of this.circuits.entries()) {
-      if (record.state === "closed" && record.failures === 0 && record.lastFailureTime > 0 && now - record.lastFailureTime > this.staleThresholdMs) {
-        this.circuits.delete(key);
-        cleaned++;
-      }
-    }
-    if (cleaned > 0) {
-      logInfo(`Circuit breaker cleanup: removed ${cleaned} stale circuits`);
-    }
-    return cleaned;
-  }
-  getKeyStrategy() {
-    return this.keyStrategy;
-  }
-  destroy() {
-    if (this.cleanupTimer) {
-      clearInterval(this.cleanupTimer);
-      this.cleanupTimer = null;
-    }
-    this.circuits.clear();
-  }
-  shutdown() {
-    this.destroy();
-  }
-  startCleanupTimer(intervalMs) {
-    this.cleanupTimer = setInterval(() => {
-      this.cleanup();
-    }, intervalMs);
-    this.cleanupTimer.unref();
+    const ttl = specTtlMs ?? headerTtl;
+    cache.set(url, parsed.etag, data, parsed.raw, ttl);
+    const ttlInfo = ttl ? ` (ttl=${ttl}ms)` : "";
+    logDebug(`Cached response for ${url} with ETag ${parsed.etag}${ttlInfo}`);
   }
-};
-var CircuitOpenError = class extends Error {
-  endpoint;
-  failures;
-  retryAfterMs;
-  constructor(endpoint, failures, retryAfterMs) {
-    super(
-      `Circuit breaker open for ${endpoint} after ${failures} failures (retry after ${Math.ceil(retryAfterMs / 1e3)}s)`
-    );
-    this.name = "CircuitOpenError";
-    this.endpoint = endpoint;
-    this.failures = failures;
-    this.retryAfterMs = retryAfterMs;
+  if (method !== "GET" && cache) {
+    cache.deleteByPath(endpoint.split("?")[0]);
   }
-};
+}
 
 // src/core/requestPipeline/statusHandling.ts
 var STATUS_MESSAGES = {
@@ -894,11 +902,11 @@ var STATUS_MESSAGES = {
 };
 function handleEarlyStatus(client, status, url, parsed, useETag, resolveCache2) {
   if (status === 201) {
-    return { headers: parsed.raw, body: void 0 };
+    return { headers: parsed.raw, body: void 0, status: 201 };
   }
   if (status === 204) {
     logInfo(`No Content for endpoint: ${url}`);
-    return { headers: parsed.raw, body: void 0 };
+    return { headers: parsed.raw, body: void 0, status: 204 };
   }
   if (status === 304) {
     const cache = resolveCache2(client);
@@ -909,6 +917,7 @@ function handleEarlyStatus(client, status, url, parsed, useETag, resolveCache2)
         return {
           headers: { ...cachedEntry.headers, ...parsed.raw },
           body: cachedEntry.data,
+          status: 304,
           fromCache: true,
           cacheHitType: "etag-304"
         };
@@ -934,7 +943,7 @@ function handleErrorResponse(client, response, url, parsed, useETag, resolveCach
     );
     if (staleResult) {
       logWarn(`${errorMessage} for ${url} \u2014 serving stale cache`);
-      return staleResult;
+      return { ...staleResult, status: response.status };
     }
   }
   if (response.status === 420 || response.status === 429) {
@@ -959,18 +968,102 @@ function wrapError(error) {
   throw buildError(String(error), "ESIJS_ERROR");
 }
 
+// src/core/util/retry.ts
+function retryDelay(attempt, baseMs, maxMs) {
+  const exponential = baseMs * Math.pow(2, attempt);
+  const jitter = exponential * (0.75 + Math.random() * 0.5);
+  return Math.min(jitter, maxMs);
+}
+
 // src/core/util/sleep.ts
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+// src/core/RetryStrategy.ts
+var RetryStrategy = class {
+  maxRetries;
+  baseDelayMs;
+  maxDelayMs;
+  retryMutations;
+  constructor(config) {
+    this.maxRetries = config?.maxRetries ?? 0;
+    this.baseDelayMs = config?.baseDelayMs ?? 1e3;
+    this.maxDelayMs = config?.maxDelayMs ?? 3e4;
+    this.retryMutations = config?.retryMutations ?? false;
+  }
+  async execute(operation, context) {
+    const canRetryMethod = context.method === "GET" || this.retryMutations;
+    let lastError;
+    let refreshAttempted = false;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      try {
+        return await operation();
+      } catch (error) {
+        if (error instanceof CircuitOpenError) {
+          throw error;
+        }
+        if (!refreshAttempted && error instanceof EsiError && error.statusCode === 401 && context.requiresAuth && context.refreshToken) {
+          refreshAttempted = true;
+          logInfo("Received 401, attempting token refresh...");
+          try {
+            await context.refreshToken();
+          } catch (refreshError) {
+            if (refreshError instanceof EsiError || refreshError instanceof CircuitOpenError) {
+              throw refreshError;
+            }
+            const msg = refreshError instanceof Error ? refreshError.message : String(refreshError);
+            logError(`Token refresh failed: ${msg}`);
+            throw buildError(
+              `Token refresh failed: ${msg}`,
+              "TOKEN_REFRESH_FAILED"
+            );
+          }
+          logInfo("Token refreshed, retrying request");
+          attempt--;
+          continue;
+        }
+        if (error instanceof EsiError && error.retryable && canRetryMethod && attempt < this.maxRetries) {
+          const delay = retryDelay(attempt, this.baseDelayMs, this.maxDelayMs);
+          logWarn(
+            `Request to ${context.endpoint} failed (${error.statusCode}), retrying in ${Math.round(delay)}ms (attempt ${attempt + 1}/${this.maxRetries})`
+          );
+          await sleep(delay);
+          lastError = error;
+          continue;
+        }
+        throw error;
+      }
+    }
+    throw lastError;
+  }
+};
+
+// src/core/requestPipeline/dependencies.ts
+function resolveCache(client) {
+  return client.getCache();
+}
+function resolveRateLimiter(client) {
+  const limiter = client.getRateLimiter();
+  if (!limiter) {
+    throw buildError(
+      "No rate limiter configured on ApiClient. Set one via apiClient.setRateLimiter(new RateLimiter()).",
+      "CONFIGURATION_ERROR"
+    );
+  }
+  return limiter;
+}
+function resolveCircuitBreaker(client) {
+  return client.getCircuitBreaker();
+}
+function resolveRetryStrategy(client) {
+  return client.getRetryStrategy() ?? new RetryStrategy(client.getRetryConfig() ?? void 0);
+}
+
 // src/core/pagination/PaginationHandler.ts
 var PaginationHandler = class {
   static DEFAULT_OPTIONS = {
     maxPages: 1e3,
-    // Reasonable limit to prevent infinite loops
-    maxRetries: 3,
-    retryDelayMs: 1e3,
     stopOnEmptyPage: true
   };
   /**
@@ -990,9 +1083,11 @@ var PaginationHandler = class {
       try {
         if (rateLimiter) await rateLimiter.checkRateLimit(templatePath, method);
         const pageData = await this.fetchPageWithRetry(
+          client,
           endpoint,
+          method,
+          requiresAuth,
           page,
-          opts,
           pageFetch
         );
         if (opts.stopOnEmptyPage && (!pageData || pageData.length === 0)) {
@@ -1016,36 +1111,35 @@ var PaginationHandler = class {
     return allData;
   }
   /**
-   * Fetch a single page with retry logic
+   * Fetch a single page with retry logic.
+   *
+   * Delegates to the configured `IRetryStrategy` (exponential backoff
+   * with jitter) instead of implementing a custom retry loop.
    */
-  static async fetchPageWithRetry(endpoint, page, options, pageFetch) {
-    let lastError = null;
-    for (let attempt = 1; attempt <= options.maxRetries; attempt++) {
-      try {
-        return await this.fetchSinglePage(endpoint, page, pageFetch);
-      } catch (error) {
-        lastError = error;
-        logWarn(
-          `Attempt ${attempt}/${options.maxRetries} failed for page ${page}: ${error instanceof Error ? error.message : String(error)}`
-        );
-        if (attempt < options.maxRetries) {
-          await sleep(options.retryDelayMs * attempt);
-        }
+  static async fetchPageWithRetry(client, endpoint, method, requiresAuth, page, pageFetch) {
+    const retryStrategy = resolveRetryStrategy(client);
+    const paginatedEndpoint = this.buildPaginatedEndpoint(endpoint, page);
+    return retryStrategy.execute(
+      () => {
+        logInfo(`Fetching page ${page} via pipeline: ${paginatedEndpoint}`);
+        return pageFetch(paginatedEndpoint);
+      },
+      {
+        endpoint: paginatedEndpoint,
+        method,
+        requiresAuth,
+        refreshToken: client.hasTokenProvider() ? () => client.refreshToken().then(() => {
+        }) : void 0
       }
-    }
-    throw lastError || new Error(
-      `Failed to fetch page ${page} after ${options.maxRetries} attempts`
     );
   }
   /**
-   * Fetch a single page.
+   * Build a paginated endpoint path.
    * Preserves any existing query params on the endpoint and appends page=N.
    */
-  static async fetchSinglePage(endpoint, page, pageFetch) {
+  static buildPaginatedEndpoint(endpoint, page) {
     const separator = endpoint.includes("?") ? "&" : "?";
-    const paginatedEndpoint = `${endpoint}${separator}page=${page}`;
-    logInfo(`Fetching page ${page} via pipeline: ${paginatedEndpoint}`);
-    return pageFetch(paginatedEndpoint);
+    return `${endpoint}${separator}page=${page}`;
   }
 };
 
@@ -1056,12 +1150,12 @@ function handleCursorPagination(parsed, data) {
     before: parsed.cursorBefore,
     after: parsed.cursorAfter
   };
-  return { headers: parsed.raw, body: data, cursors };
+  return { headers: parsed.raw, body: data, status: 200, cursors };
 }
 async function handleOffsetPagination(client, endpoint, method, requiresAuth, parsed, data, body, url, useETag, pageFetch, resolveCache2, templatePath) {
   const totalPages = parsed.xPages;
   if (totalPages <= 1) {
-    return { headers: parsed.raw, body: data };
+    return { headers: parsed.raw, body: data, status: 200 };
   }
   logInfo(
     `Found ${totalPages} pages, fetching additional pages with rate limiting...`
@@ -1078,8 +1172,7 @@ async function handleOffsetPagination(client, endpoint, method, requiresAuth, pa
       body,
       {
         maxPages: Math.min(totalPages, 1e3),
-        stopOnEmptyPage: true,
-        maxRetries: 3
+        stopOnEmptyPage: true
       },
       pageFetch,
       templatePath
@@ -1095,7 +1188,7 @@ async function handleOffsetPagination(client, endpoint, method, requiresAuth, pa
       resolveCache2,
       templatePath
     );
-    return { headers: parsed.raw, body: allData };
+    return { headers: parsed.raw, body: allData, status: 200 };
   } catch (paginationError) {
     const msg = paginationError instanceof Error ? paginationError.message : String(paginationError);
     logWarn(`Pagination failed for ${url}: ${msg}`);
@@ -1137,7 +1230,7 @@ async function applyResponseInterceptors(client, result, url, endpoint, method,
     url,
     endpoint,
     method,
-    status: 200,
+    status: result.status ?? 200,
     headers: result.headers,
     body: result.body,
     durationMs: Date.now() - startTime,
@@ -1299,93 +1392,6 @@ async function fetchOnePage(client, endpoint, method, body, requiresAuth, useETa
   return { data, parsed, url };
 }
 
-// src/core/util/retry.ts
-function retryDelay(attempt, baseMs, maxMs) {
-  const exponential = baseMs * Math.pow(2, attempt);
-  const jitter = exponential * (0.75 + Math.random() * 0.5);
-  return Math.min(jitter, maxMs);
-}
-
-// src/core/RetryStrategy.ts
-var RetryStrategy = class {
-  maxRetries;
-  baseDelayMs;
-  maxDelayMs;
-  retryMutations;
-  constructor(config) {
-    this.maxRetries = config?.maxRetries ?? 0;
-    this.baseDelayMs = config?.baseDelayMs ?? 1e3;
-    this.maxDelayMs = config?.maxDelayMs ?? 3e4;
-    this.retryMutations = config?.retryMutations ?? false;
-  }
-  async execute(operation, context) {
-    const canRetryMethod = context.method === "GET" || this.retryMutations;
-    let lastError;
-    let refreshAttempted = false;
-    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
-      try {
-        return await operation();
-      } catch (error) {
-        if (error instanceof CircuitOpenError) {
-          throw error;
-        }
-        if (!refreshAttempted && error instanceof EsiError && error.statusCode === 401 && context.requiresAuth && context.refreshToken) {
-          refreshAttempted = true;
-          logInfo("Received 401, attempting token refresh...");
-          try {
-            await context.refreshToken();
-          } catch (refreshError) {
-            if (refreshError instanceof EsiError || refreshError instanceof CircuitOpenError) {
-              throw refreshError;
-            }
-            const msg = refreshError instanceof Error ? refreshError.message : String(refreshError);
-            logError(`Token refresh failed: ${msg}`);
-            throw buildError(
-              `Token refresh failed: ${msg}`,
-              "TOKEN_REFRESH_FAILED"
-            );
-          }
-          logInfo("Token refreshed, retrying request");
-          attempt--;
-          continue;
-        }
-        if (error instanceof EsiError && error.retryable && canRetryMethod && attempt < this.maxRetries) {
-          const delay = retryDelay(attempt, this.baseDelayMs, this.maxDelayMs);
-          logWarn(
-            `Request to ${context.endpoint} failed (${error.statusCode}), retrying in ${Math.round(delay)}ms (attempt ${attempt + 1}/${this.maxRetries})`
-          );
-          await sleep(delay);
-          lastError = error;
-          continue;
-        }
-        throw error;
-      }
-    }
-    throw lastError;
-  }
-};
-
-// src/core/requestPipeline/dependencies.ts
-function resolveCache(client) {
-  return client.getCache();
-}
-function resolveRateLimiter(client) {
-  const limiter = client.getRateLimiter();
-  if (!limiter) {
-    throw buildError(
-      "No rate limiter configured on ApiClient. Set one via apiClient.setRateLimiter(new RateLimiter()).",
-      "CONFIGURATION_ERROR"
-    );
-  }
-  return limiter;
-}
-function resolveCircuitBreaker(client) {
-  return client.getCircuitBreaker();
-}
-function resolveRetryStrategy(client) {
-  return client.getRetryStrategy() ?? new RetryStrategy(client.getRetryConfig() ?? void 0);
-}
-
 // src/core/ApiRequestHandler.ts
 var executeRequest = async (client, endpoint, method, body, requiresAuth = false, useETag = true, requestTimeout, templatePath) => {
   const startTime = Date.now();
@@ -1422,7 +1428,7 @@ var executeRequest = async (client, endpoint, method, body, requiresAuth = false
       } catch {
         data2 = void 0;
       }
-      return finish({ headers: parsed.raw, body: data2 });
+      return finish({ headers: parsed.raw, body: data2, status: 201 });
     }
     const earlyResult = handleEarlyStatus(
       client,
@@ -4032,76 +4038,184 @@ var CorporationsClient = class extends BaseEsiClient {
       corporationId
     );
   }
-  streamNpcCorporations() {
-    return this.streamEndpoint("getNpcCorporations");
+  streamNpcCorporations() {
+    return this.streamEndpoint("getNpcCorporations");
+  }
+};
+
+// src/core/endpoints/corporationProjectEndpoints.ts
+var import_zod19 = require("zod");
+
+// src/schemas/corporation-projects.ts
+var import_zod18 = require("zod");
+var CorporationProjectSchema = import_zod18.z.looseObject({
+  project_id: import_zod18.z.number(),
+  state: import_zod18.z.string(),
+  progress: import_zod18.z.number(),
+  start_time: import_zod18.z.string(),
+  finish_time: import_zod18.z.string().optional()
+});
+var CorporationProjectContributionSchema = import_zod18.z.looseObject({
+  character_id: import_zod18.z.number(),
+  contribution: import_zod18.z.number()
+});
+var CorporationProjectContributorSchema = import_zod18.z.looseObject({
+  character_id: import_zod18.z.number(),
+  contribution: import_zod18.z.number()
+});
+
+// src/core/endpoints/corporationProjectEndpoints.ts
+var corporationProjectEndpoints = {
+  getCorporationProjects: {
+    path: "corporations/{corporationId}/projects",
+    method: "GET",
+    requiresAuth: true,
+    pathParams: ["corporationId"],
+    responseSchema: import_zod19.z.array(CorporationProjectSchema)
+  },
+  getCorporationProject: {
+    path: "corporations/{corporationId}/projects/{projectId}",
+    method: "GET",
+    requiresAuth: true,
+    pathParams: ["corporationId", "projectId"],
+    responseSchema: CorporationProjectSchema
+  },
+  getCorporationProjectContribution: {
+    path: "corporations/{corporationId}/projects/{projectId}/contribution/{characterId}",
+    method: "GET",
+    requiresAuth: true,
+    pathParams: ["corporationId", "projectId", "characterId"],
+    responseSchema: CorporationProjectContributionSchema
+  },
+  getCorporationProjectContributors: {
+    path: "corporations/{corporationId}/projects/{projectId}/contributors",
+    method: "GET",
+    requiresAuth: true,
+    pathParams: ["corporationId", "projectId"],
+    responseSchema: import_zod19.z.array(CorporationProjectContributorSchema)
+  }
+};
+
+// src/clients/CorporationProjectsClient.ts
+var CorporationProjectsClient = class extends BaseEsiClient {
+  constructor(client) {
+    super(client, corporationProjectEndpoints);
+  }
+  /**
+   * Retrieves a list of projects for a corporation.
+   *
+   * @param corporationId - The ID of the corporation
+   * @returns An array of corporation projects
+   * @requires Authentication
+   */
+  getCorporationProjects(corporationId) {
+    return this.api.getCorporationProjects(corporationId);
+  }
+  /**
+   * Retrieves details of a specific corporation project.
+   *
+   * @param corporationId - The ID of the corporation
+   * @param projectId - The ID of the project
+   * @returns The corporation project details
+   * @requires Authentication
+   */
+  getCorporationProject(corporationId, projectId) {
+    return this.api.getCorporationProject(corporationId, projectId);
+  }
+  /**
+   * Retrieves a character's contribution to a specific corporation project.
+   *
+   * @param corporationId - The ID of the corporation
+   * @param projectId - The ID of the project
+   * @param characterId - The ID of the character
+   * @returns The character's contribution details
+   * @requires Authentication
+   */
+  getCorporationProjectContribution(corporationId, projectId, characterId) {
+    return this.api.getCorporationProjectContribution(
+      corporationId,
+      projectId,
+      characterId
+    );
+  }
+  /**
+   * Retrieves a list of contributors to a specific corporation project.
+   *
+   * @param corporationId - The ID of the corporation
+   * @param projectId - The ID of the project
+   * @returns An array of project contributors
+   * @requires Authentication
+   */
+  getCorporationProjectContributors(corporationId, projectId) {
+    return this.api.getCorporationProjectContributors(corporationId, projectId);
   }
 };
 
 // src/core/endpoints/dogmaEndpoints.ts
-var import_zod19 = require("zod");
+var import_zod21 = require("zod");
 
 // src/schemas/dogma.ts
-var import_zod18 = require("zod");
-var DogmaAttributeSchema = import_zod18.z.looseObject({
-  attribute_id: import_zod18.z.number(),
-  name: import_zod18.z.string(),
-  description: import_zod18.z.string().optional(),
-  icon_id: import_zod18.z.number().optional(),
-  default_value: import_zod18.z.number().optional(),
-  published: import_zod18.z.boolean().optional(),
-  display_name: import_zod18.z.string().optional(),
-  unit_id: import_zod18.z.number().optional(),
-  stackable: import_zod18.z.boolean().optional(),
-  high_is_good: import_zod18.z.boolean().optional()
-});
-var DogmaEffectSchema = import_zod18.z.looseObject({
-  effect_id: import_zod18.z.number(),
-  name: import_zod18.z.string(),
-  description: import_zod18.z.string().optional(),
-  icon_id: import_zod18.z.number().optional(),
-  display_name: import_zod18.z.string().optional(),
-  published: import_zod18.z.boolean().optional(),
-  effect_category: import_zod18.z.number().optional(),
-  is_assistance: import_zod18.z.boolean().optional(),
-  is_offensive: import_zod18.z.boolean().optional(),
-  is_warp_safe: import_zod18.z.boolean().optional(),
-  disallow_auto_repeat: import_zod18.z.boolean().optional(),
-  discharge_attribute_id: import_zod18.z.number().optional(),
-  duration_attribute_id: import_zod18.z.number().optional(),
-  electronic_chance: import_zod18.z.boolean().optional(),
-  falloff_attribute_id: import_zod18.z.number().optional(),
-  modifiers: import_zod18.z.array(
-    import_zod18.z.looseObject({
-      domain: import_zod18.z.string().optional(),
-      effect_id: import_zod18.z.number().optional(),
-      func: import_zod18.z.string(),
-      modified_attribute_id: import_zod18.z.number().optional(),
-      modifying_attribute_id: import_zod18.z.number().optional(),
-      operator: import_zod18.z.number().optional()
+var import_zod20 = require("zod");
+var DogmaAttributeSchema = import_zod20.z.looseObject({
+  attribute_id: import_zod20.z.number(),
+  name: import_zod20.z.string(),
+  description: import_zod20.z.string().optional(),
+  icon_id: import_zod20.z.number().optional(),
+  default_value: import_zod20.z.number().optional(),
+  published: import_zod20.z.boolean().optional(),
+  display_name: import_zod20.z.string().optional(),
+  unit_id: import_zod20.z.number().optional(),
+  stackable: import_zod20.z.boolean().optional(),
+  high_is_good: import_zod20.z.boolean().optional()
+});
+var DogmaEffectSchema = import_zod20.z.looseObject({
+  effect_id: import_zod20.z.number(),
+  name: import_zod20.z.string(),
+  description: import_zod20.z.string().optional(),
+  icon_id: import_zod20.z.number().optional(),
+  display_name: import_zod20.z.string().optional(),
+  published: import_zod20.z.boolean().optional(),
+  effect_category: import_zod20.z.number().optional(),
+  is_assistance: import_zod20.z.boolean().optional(),
+  is_offensive: import_zod20.z.boolean().optional(),
+  is_warp_safe: import_zod20.z.boolean().optional(),
+  disallow_auto_repeat: import_zod20.z.boolean().optional(),
+  discharge_attribute_id: import_zod20.z.number().optional(),
+  duration_attribute_id: import_zod20.z.number().optional(),
+  electronic_chance: import_zod20.z.boolean().optional(),
+  falloff_attribute_id: import_zod20.z.number().optional(),
+  modifiers: import_zod20.z.array(
+    import_zod20.z.looseObject({
+      domain: import_zod20.z.string().optional(),
+      effect_id: import_zod20.z.number().optional(),
+      func: import_zod20.z.string(),
+      modified_attribute_id: import_zod20.z.number().optional(),
+      modifying_attribute_id: import_zod20.z.number().optional(),
+      operator: import_zod20.z.number().optional()
     })
   ).optional(),
-  post_expression: import_zod18.z.number().optional(),
-  pre_expression: import_zod18.z.number().optional(),
-  range_attribute_id: import_zod18.z.number().optional(),
-  range_chance: import_zod18.z.boolean().optional(),
-  tracking_speed_attribute_id: import_zod18.z.number().optional()
-});
-var DogmaDynamicItemSchema = import_zod18.z.looseObject({
-  created_by: import_zod18.z.number(),
-  dogma_attributes: import_zod18.z.array(
-    import_zod18.z.looseObject({
-      attribute_id: import_zod18.z.number(),
-      value: import_zod18.z.number()
+  post_expression: import_zod20.z.number().optional(),
+  pre_expression: import_zod20.z.number().optional(),
+  range_attribute_id: import_zod20.z.number().optional(),
+  range_chance: import_zod20.z.boolean().optional(),
+  tracking_speed_attribute_id: import_zod20.z.number().optional()
+});
+var DogmaDynamicItemSchema = import_zod20.z.looseObject({
+  created_by: import_zod20.z.number(),
+  dogma_attributes: import_zod20.z.array(
+    import_zod20.z.looseObject({
+      attribute_id: import_zod20.z.number(),
+      value: import_zod20.z.number()
     })
   ),
-  dogma_effects: import_zod18.z.array(
-    import_zod18.z.looseObject({
-      effect_id: import_zod18.z.number(),
-      is_default: import_zod18.z.boolean()
+  dogma_effects: import_zod20.z.array(
+    import_zod20.z.looseObject({
+      effect_id: import_zod20.z.number(),
+      is_default: import_zod20.z.boolean()
     })
   ),
-  mutator_type_id: import_zod18.z.number(),
-  source_type_id: import_zod18.z.number()
+  mutator_type_id: import_zod20.z.number(),
+  source_type_id: import_zod20.z.number()
 });
 
 // src/core/endpoints/dogmaEndpoints.ts
@@ -4110,7 +4224,7 @@ var dogmaEndpoints = {
     path: "dogma/attributes",
     method: "GET",
     requiresAuth: false,
-    responseSchema: import_zod19.z.array(import_zod19.z.number())
+    responseSchema: import_zod21.z.array(import_zod21.z.number())
   },
   getAttributeById: {
     path: "dogma/attributes/{attributeId}",
@@ -4123,7 +4237,7 @@ var dogmaEndpoints = {
     path: "dogma/effects",
     method: "GET",
     requiresAuth: false,
-    responseSchema: import_zod19.z.array(import_zod19.z.number())
+    responseSchema: import_zod21.z.array(import_zod21.z.number())
   },
   getEffectById: {
     path: "dogma/effects/{effectId}",
@@ -4196,108 +4310,108 @@ var DogmaClient = class extends BaseEsiClient {
 };
 
 // src/core/endpoints/factionEndpoints.ts
-var import_zod21 = require("zod");
+var import_zod23 = require("zod");
 
 // src/schemas/faction-warfare.ts
-var import_zod20 = require("zod");
-var FactionWarfareStatsSchema = import_zod20.z.looseObject({
-  faction_id: import_zod20.z.number(),
-  pilots: import_zod20.z.number(),
-  systems_controlled: import_zod20.z.number(),
-  kills: import_zod20.z.looseObject({
-    yesterday: import_zod20.z.number(),
-    last_week: import_zod20.z.number(),
-    total: import_zod20.z.number()
+var import_zod22 = require("zod");
+var FactionWarfareStatsSchema = import_zod22.z.looseObject({
+  faction_id: import_zod22.z.number(),
+  pilots: import_zod22.z.number(),
+  systems_controlled: import_zod22.z.number(),
+  kills: import_zod22.z.looseObject({
+    yesterday: import_zod22.z.number(),
+    last_week: import_zod22.z.number(),
+    total: import_zod22.z.number()
   }),
-  victory_points: import_zod20.z.looseObject({
-    yesterday: import_zod20.z.number(),
-    last_week: import_zod20.z.number(),
-    total: import_zod20.z.number()
+  victory_points: import_zod22.z.looseObject({
+    yesterday: import_zod22.z.number(),
+    last_week: import_zod22.z.number(),
+    total: import_zod22.z.number()
   })
 });
-var FactionWarfareCharacterStatsSchema = import_zod20.z.looseObject({
-  faction_id: import_zod20.z.number().optional(),
-  enlisted_on: import_zod20.z.string().optional(),
-  current_rank: import_zod20.z.number().optional(),
-  highest_rank: import_zod20.z.number().optional(),
-  kills: import_zod20.z.looseObject({
-    yesterday: import_zod20.z.number(),
-    last_week: import_zod20.z.number(),
-    total: import_zod20.z.number()
+var FactionWarfareCharacterStatsSchema = import_zod22.z.looseObject({
+  faction_id: import_zod22.z.number().optional(),
+  enlisted_on: import_zod22.z.string().optional(),
+  current_rank: import_zod22.z.number().optional(),
+  highest_rank: import_zod22.z.number().optional(),
+  kills: import_zod22.z.looseObject({
+    yesterday: import_zod22.z.number(),
+    last_week: import_zod22.z.number(),
+    total: import_zod22.z.number()
   }),
-  victory_points: import_zod20.z.looseObject({
-    yesterday: import_zod20.z.number(),
-    last_week: import_zod20.z.number(),
-    total: import_zod20.z.number()
+  victory_points: import_zod22.z.looseObject({
+    yesterday: import_zod22.z.number(),
+    last_week: import_zod22.z.number(),
+    total: import_zod22.z.number()
   })
 });
-var FactionWarfareSystemSchema = import_zod20.z.looseObject({
-  solar_system_id: import_zod20.z.number(),
-  owner_faction_id: import_zod20.z.number(),
-  occupier_faction_id: import_zod20.z.number(),
-  contested: import_zod20.z.enum(["captured", "contested", "uncontested", "vulnerable"]),
-  victory_points: import_zod20.z.number(),
-  victory_points_threshold: import_zod20.z.number()
-});
-var FactionWarfareWarSchema = import_zod20.z.looseObject({
-  faction_id: import_zod20.z.number(),
-  against_id: import_zod20.z.number()
-});
-var FactionWarfareLeaderboardSchema = import_zod20.z.looseObject({
-  kills: import_zod20.z.looseObject({
-    yesterday: import_zod20.z.array(
-      import_zod20.z.looseObject({
-        amount: import_zod20.z.number(),
-        id: import_zod20.z.number().optional()
+var FactionWarfareSystemSchema = import_zod22.z.looseObject({
+  solar_system_id: import_zod22.z.number(),
+  owner_faction_id: import_zod22.z.number(),
+  occupier_faction_id: import_zod22.z.number(),
+  contested: import_zod22.z.enum(["captured", "contested", "uncontested", "vulnerable"]),
+  victory_points: import_zod22.z.number(),
+  victory_points_threshold: import_zod22.z.number()
+});
+var FactionWarfareWarSchema = import_zod22.z.looseObject({
+  faction_id: import_zod22.z.number(),
+  against_id: import_zod22.z.number()
+});
+var FactionWarfareLeaderboardSchema = import_zod22.z.looseObject({
+  kills: import_zod22.z.looseObject({
+    yesterday: import_zod22.z.array(
+      import_zod22.z.looseObject({
+        amount: import_zod22.z.number(),
+        id: import_zod22.z.number().optional()
       })
     ),
-    last_week: import_zod20.z.array(
-      import_zod20.z.looseObject({
-        amount: import_zod20.z.number(),
-        id: import_zod20.z.number().optional()
+    last_week: import_zod22.z.array(
+      import_zod22.z.looseObject({
+        amount: import_zod22.z.number(),
+        id: import_zod22.z.number().optional()
       })
     ),
-    active_total: import_zod20.z.array(
-      import_zod20.z.looseObject({
-        amount: import_zod20.z.number(),
-        id: import_zod20.z.number().optional()
+    active_total: import_zod22.z.array(
+      import_zod22.z.looseObject({
+        amount: import_zod22.z.number(),
+        id: import_zod22.z.number().optional()
       })
     )
   }),
-  victory_points: import_zod20.z.looseObject({
-    yesterday: import_zod20.z.array(
-      import_zod20.z.looseObject({
-        amount: import_zod20.z.number(),
-        id: import_zod20.z.number().optional()
+  victory_points: import_zod22.z.looseObject({
+    yesterday: import_zod22.z.array(
+      import_zod22.z.looseObject({
+        amount: import_zod22.z.number(),
+        id: import_zod22.z.number().optional()
       })
     ),
-    last_week: import_zod20.z.array(
-      import_zod20.z.looseObject({
-        amount: import_zod20.z.number(),
-        id: import_zod20.z.number().optional()
+    last_week: import_zod22.z.array(
+      import_zod22.z.looseObject({
+        amount: import_zod22.z.number(),
+        id: import_zod22.z.number().optional()
       })
     ),
-    active_total: import_zod20.z.array(
-      import_zod20.z.looseObject({
-        amount: import_zod20.z.number(),
-        id: import_zod20.z.number().optional()
+    active_total: import_zod22.z.array(
+      import_zod22.z.looseObject({
+        amount: import_zod22.z.number(),
+        id: import_zod22.z.number().optional()
       })
     )
   })
 });
-var FactionWarfareCorporationStatsSchema = import_zod20.z.looseObject({
-  faction_id: import_zod20.z.number().optional(),
-  enlisted_on: import_zod20.z.string().optional(),
-  pilots: import_zod20.z.number().optional(),
-  kills: import_zod20.z.looseObject({
-    yesterday: import_zod20.z.number(),
-    last_week: import_zod20.z.number(),
-    total: import_zod20.z.number()
+var FactionWarfareCorporationStatsSchema = import_zod22.z.looseObject({
+  faction_id: import_zod22.z.number().optional(),
+  enlisted_on: import_zod22.z.string().optional(),
+  pilots: import_zod22.z.number().optional(),
+  kills: import_zod22.z.looseObject({
+    yesterday: import_zod22.z.number(),
+    last_week: import_zod22.z.number(),
+    total: import_zod22.z.number()
   }),
-  victory_points: import_zod20.z.looseObject({
-    yesterday: import_zod20.z.number(),
-    last_week: import_zod20.z.number(),
-    total: import_zod20.z.number()
+  victory_points: import_zod22.z.looseObject({
+    yesterday: import_zod22.z.number(),
+    last_week: import_zod22.z.number(),
+    total: import_zod22.z.number()
   })
 });
 
@@ -4339,19 +4453,19 @@ var factionEndpoints = {
     path: "fw/stats",
     method: "GET",
     requiresAuth: false,
-    responseSchema: import_zod21.z.array(FactionWarfareStatsSchema)
+    responseSchema: import_zod23.z.array(FactionWarfareStatsSchema)
   },
   getSystems: {
     path: "fw/systems",
     method: "GET",
     requiresAuth: false,
-    responseSchema: import_zod21.z.array(FactionWarfareSystemSchema)
+    responseSchema: import_zod23.z.array(FactionWarfareSystemSchema)
   },
   getWars: {
     path: "fw/wars",
     method: "GET",
     requiresAuth: false,
-    responseSchema: import_zod21.z.array(FactionWarfareWarSchema)
+    responseSchema: import_zod23.z.array(FactionWarfareWarSchema)
   }
 };
 
@@ -4435,20 +4549,20 @@ var FactionClient = class extends BaseEsiClient {
 };
 
 // src/core/endpoints/fittingEndpoints.ts
-var import_zod23 = require("zod");
+var import_zod25 = require("zod");
 
 // src/schemas/fittings.ts
-var import_zod22 = require("zod");
-var FittingSchema = import_zod22.z.looseObject({
-  fitting_id: import_zod22.z.number(),
-  name: import_zod22.z.string(),
-  description: import_zod22.z.string(),
-  ship_type_id: import_zod22.z.number(),
-  items: import_zod22.z.array(
-    import_zod22.z.looseObject({
-      type_id: import_zod22.z.number(),
-      flag: import_zod22.z.union([import_zod22.z.number(), import_zod22.z.string()]),
-      quantity: import_zod22.z.number()
+var import_zod24 = require("zod");
+var FittingSchema = import_zod24.z.looseObject({
+  fitting_id: import_zod24.z.number(),
+  name: import_zod24.z.string(),
+  description: import_zod24.z.string(),
+  ship_type_id: import_zod24.z.number(),
+  items: import_zod24.z.array(
+    import_zod24.z.looseObject({
+      type_id: import_zod24.z.number(),
+      flag: import_zod24.z.union([import_zod24.z.number(), import_zod24.z.string()]),
+      quantity: import_zod24.z.number()
     })
   )
 });
@@ -4460,7 +4574,7 @@ var fittingEndpoints = {
     method: "GET",
     requiresAuth: true,
     pathParams: ["characterId"],
-    responseSchema: import_zod23.z.array(FittingSchema)
+    responseSchema: import_zod25.z.array(FittingSchema)
   },
   createFitting: {
     path: "characters/{characterId}/fittings",
@@ -4519,56 +4633,56 @@ var FittingsClient = class extends BaseEsiClient {
 };
 
 // src/core/endpoints/fleetEndpoints.ts
-var import_zod25 = require("zod");
+var import_zod27 = require("zod");
 
 // src/schemas/fleet.ts
-var import_zod24 = require("zod");
-var FleetInfoSchema = import_zod24.z.looseObject({
-  fleet_id: import_zod24.z.number().optional(),
-  fleet_boss_id: import_zod24.z.number().optional(),
-  is_free_move: import_zod24.z.boolean(),
-  is_registered: import_zod24.z.boolean(),
-  is_voice_enabled: import_zod24.z.boolean(),
-  motd: import_zod24.z.string()
-});
-var FleetMemberSchema = import_zod24.z.looseObject({
-  character_id: import_zod24.z.number(),
-  ship_type_id: import_zod24.z.number(),
-  wing_id: import_zod24.z.number(),
-  squad_id: import_zod24.z.number(),
-  role: import_zod24.z.enum([
+var import_zod26 = require("zod");
+var FleetInfoSchema = import_zod26.z.looseObject({
+  fleet_id: import_zod26.z.number().optional(),
+  fleet_boss_id: import_zod26.z.number().optional(),
+  is_free_move: import_zod26.z.boolean(),
+  is_registered: import_zod26.z.boolean(),
+  is_voice_enabled: import_zod26.z.boolean(),
+  motd: import_zod26.z.string()
+});
+var FleetMemberSchema = import_zod26.z.looseObject({
+  character_id: import_zod26.z.number(),
+  ship_type_id: import_zod26.z.number(),
+  wing_id: import_zod26.z.number(),
+  squad_id: import_zod26.z.number(),
+  role: import_zod26.z.enum([
     "fleet_commander",
     "wing_commander",
     "squad_commander",
     "squad_member"
   ]),
-  role_name: import_zod24.z.string(),
-  join_time: import_zod24.z.string(),
-  takes_fleet_warp: import_zod24.z.boolean(),
-  solar_system_id: import_zod24.z.number(),
-  station_id: import_zod24.z.number().optional()
-});
-var FleetWingSchema = import_zod24.z.looseObject({
-  id: import_zod24.z.number(),
-  name: import_zod24.z.string(),
-  squads: import_zod24.z.array(
-    import_zod24.z.looseObject({
-      id: import_zod24.z.number(),
-      name: import_zod24.z.string()
+  role_name: import_zod26.z.string(),
+  join_time: import_zod26.z.string(),
+  takes_fleet_warp: import_zod26.z.boolean(),
+  solar_system_id: import_zod26.z.number(),
+  station_id: import_zod26.z.number().optional()
+});
+var FleetWingSchema = import_zod26.z.looseObject({
+  id: import_zod26.z.number(),
+  name: import_zod26.z.string(),
+  squads: import_zod26.z.array(
+    import_zod26.z.looseObject({
+      id: import_zod26.z.number(),
+      name: import_zod26.z.string()
     })
   )
 });
-var CharacterFleetInfoSchema = import_zod24.z.looseObject({
-  fleet_id: import_zod24.z.number(),
-  fleet_boss_id: import_zod24.z.number().optional(),
-  role: import_zod24.z.enum([
+var CharacterFleetInfoSchema = import_zod26.z.looseObject({
+  fleet_id: import_zod26.z.number(),
+  fleet_boss_id: import_zod26.z.number().optional(),
+  role: import_zod26.z.enum([
     "fleet_commander",
     "wing_commander",
     "squad_commander",
     "squad_member"
   ]),
-  squad_id: import_zod24.z.number(),
-  wing_id: import_zod24.z.number()
+  squad_id: import_zod26.z.number(),
+  wing_id: import_zod26.z.number()
 });
 
 // src/core/endpoints/fleetEndpoints.ts
@@ -4593,9 +4707,9 @@ var fleetEndpoints = {
     requiresAuth: true,
     pathParams: ["fleetId"],
     hasBody: true,
-    requestSchema: import_zod25.z.looseObject({
-      is_free_move: import_zod25.z.boolean().optional(),
-      motd: import_zod25.z.string().optional()
+    requestSchema: import_zod27.z.looseObject({
+      is_free_move: import_zod27.z.boolean().optional(),
+      motd: import_zod27.z.string().optional()
     })
   },
   getFleetMembers: {
@@ -4603,7 +4717,7 @@ var fleetEndpoints = {
     method: "GET",
     requiresAuth: true,
     pathParams: ["fleetId"],
-    responseSchema: import_zod25.z.array(FleetMemberSchema)
+    responseSchema: import_zod27.z.array(FleetMemberSchema)
   },
   createFleetInvitation: {
     path: "fleets/{fleetId}/members/",
@@ -4643,7 +4757,7 @@ var fleetEndpoints = {
     method: "GET",
     requiresAuth: true,
     pathParams: ["fleetId"],
-    responseSchema: import_zod25.z.array(FleetWingSchema)
+    responseSchema: import_zod27.z.array(FleetWingSchema)
   },
   createFleetWing: {
     path: "fleets/{fleetId}/wings/",
@@ -4846,19 +4960,19 @@ var FleetClient = class extends BaseEsiClient {
 };
 
 // src/core/endpoints/incursionEndpoints.ts
-var import_zod27 = require("zod");
+var import_zod29 = require("zod");
 
 // src/schemas/incursions.ts
-var import_zod26 = require("zod");
-var IncursionSchema = import_zod26.z.looseObject({
-  type: import_zod26.z.string(),
-  state: import_zod26.z.enum(["withdrawing", "mobilizing", "established"]),
-  staging_solar_system_id: import_zod26.z.number(),
-  constellation_id: import_zod26.z.number(),
-  infested_solar_systems: import_zod26.z.array(import_zod26.z.number()),
-  has_boss: import_zod26.z.boolean(),
-  faction_id: import_zod26.z.number(),
-  influence: import_zod26.z.number()
+var import_zod28 = require("zod");
+var IncursionSchema = import_zod28.z.looseObject({
+  type: import_zod28.z.string(),
+  state: import_zod28.z.enum(["withdrawing", "mobilizing", "established"]),
+  staging_solar_system_id: import_zod28.z.number(),
+  constellation_id: import_zod28.z.number(),
+  infested_solar_systems: import_zod28.z.array(import_zod28.z.number()),
+  has_boss: import_zod28.z.boolean(),
+  faction_id: import_zod28.z.number(),
+  influence: import_zod28.z.number()
 });
 
 // src/core/endpoints/incursionEndpoints.ts
@@ -4867,7 +4981,7 @@ var incursionEndpoints = {
     path: "incursions",
     method: "GET",
     requiresAuth: false,
-    responseSchema: import_zod27.z.array(IncursionSchema)
+    responseSchema: import_zod29.z.array(IncursionSchema)
   }
 };
 
@@ -4887,26 +5001,26 @@ var IncursionsClient = class extends BaseEsiClient {
 };
 
 // src/core/endpoints/industryEndpoints.ts
-var import_zod29 = require("zod");
+var import_zod31 = require("zod");
 
 // src/schemas/industry.ts
-var import_zod28 = require("zod");
-var IndustryJobSchema = import_zod28.z.looseObject({
-  job_id: import_zod28.z.number(),
-  installer_id: import_zod28.z.number(),
-  facility_id: import_zod28.z.number(),
-  station_id: import_zod28.z.number(),
-  activity_id: import_zod28.z.number(),
-  blueprint_id: import_zod28.z.number(),
-  blueprint_type_id: import_zod28.z.number(),
-  blueprint_location_id: import_zod28.z.number(),
-  output_location_id: import_zod28.z.number(),
-  runs: import_zod28.z.number(),
-  cost: import_zod28.z.number().optional(),
-  licensed_runs: import_zod28.z.number().optional(),
-  probability: import_zod28.z.number().optional(),
-  product_type_id: import_zod28.z.number().optional(),
-  status: import_zod28.z.enum([
+var import_zod30 = require("zod");
+var IndustryJobSchema = import_zod30.z.looseObject({
+  job_id: import_zod30.z.number(),
+  installer_id: import_zod30.z.number(),
+  facility_id: import_zod30.z.number(),
+  station_id: import_zod30.z.number(),
+  activity_id: import_zod30.z.number(),
+  blueprint_id: import_zod30.z.number(),
+  blueprint_type_id: import_zod30.z.number(),
+  blueprint_location_id: import_zod30.z.number(),
+  output_location_id: import_zod30.z.number(),
+  runs: import_zod30.z.number(),
+  cost: import_zod30.z.number().optional(),
+  licensed_runs: import_zod30.z.number().optional(),
+  probability: import_zod30.z.number().optional(),
+  product_type_id: import_zod30.z.number().optional(),
+  status: import_zod30.z.enum([
     "active",
     "cancelled",
     "delivered",
@@ -4914,55 +5028,55 @@ var IndustryJobSchema = import_zod28.z.looseObject({
     "ready",
     "reverted"
   ]),
-  duration: import_zod28.z.number(),
-  start_date: import_zod28.z.string(),
-  end_date: import_zod28.z.string(),
-  pause_date: import_zod28.z.string().optional(),
-  completed_date: import_zod28.z.string().optional(),
-  completed_character_id: import_zod28.z.number().optional(),
-  successful_runs: import_zod28.z.number().optional()
-});
-var MiningLedgerEntrySchema = import_zod28.z.looseObject({
-  date: import_zod28.z.string(),
-  solar_system_id: import_zod28.z.number(),
-  type_id: import_zod28.z.number(),
-  quantity: import_zod28.z.number()
-});
-var IndustryFacilitySchema = import_zod28.z.looseObject({
-  facility_id: import_zod28.z.number(),
-  owner_id: import_zod28.z.number(),
-  region_id: import_zod28.z.number(),
-  solar_system_id: import_zod28.z.number(),
-  tax: import_zod28.z.number().optional(),
-  type_id: import_zod28.z.number()
-});
-var IndustrySystemSchema = import_zod28.z.looseObject({
-  solar_system_id: import_zod28.z.number(),
-  cost_indices: import_zod28.z.array(
-    import_zod28.z.looseObject({
-      activity: import_zod28.z.string(),
-      cost_index: import_zod28.z.number()
+  duration: import_zod30.z.number(),
+  start_date: import_zod30.z.string(),
+  end_date: import_zod30.z.string(),
+  pause_date: import_zod30.z.string().optional(),
+  completed_date: import_zod30.z.string().optional(),
+  completed_character_id: import_zod30.z.number().optional(),
+  successful_runs: import_zod30.z.number().optional()
+});
+var MiningLedgerEntrySchema = import_zod30.z.looseObject({
+  date: import_zod30.z.string(),
+  solar_system_id: import_zod30.z.number(),
+  type_id: import_zod30.z.number(),
+  quantity: import_zod30.z.number()
+});
+var IndustryFacilitySchema = import_zod30.z.looseObject({
+  facility_id: import_zod30.z.number(),
+  owner_id: import_zod30.z.number(),
+  region_id: import_zod30.z.number(),
+  solar_system_id: import_zod30.z.number(),
+  tax: import_zod30.z.number().optional(),
+  type_id: import_zod30.z.number()
+});
+var IndustrySystemSchema = import_zod30.z.looseObject({
+  solar_system_id: import_zod30.z.number(),
+  cost_indices: import_zod30.z.array(
+    import_zod30.z.looseObject({
+      activity: import_zod30.z.string(),
+      cost_index: import_zod30.z.number()
     })
   )
 });
-var MoonExtractionTimerSchema = import_zod28.z.looseObject({
-  structure_id: import_zod28.z.number(),
-  moon_id: import_zod28.z.number(),
-  extraction_start_time: import_zod28.z.string(),
-  chunk_arrival_time: import_zod28.z.string(),
-  natural_decay_time: import_zod28.z.string()
-});
-var MiningObserverSchema = import_zod28.z.looseObject({
-  observer_id: import_zod28.z.number(),
-  observer_type: import_zod28.z.string(),
-  last_updated: import_zod28.z.string()
-});
-var MiningObserverEntrySchema = import_zod28.z.looseObject({
-  character_id: import_zod28.z.number(),
-  recorded_corporation_id: import_zod28.z.number(),
-  type_id: import_zod28.z.number(),
-  quantity: import_zod28.z.number(),
-  last_updated: import_zod28.z.string()
+var MoonExtractionTimerSchema = import_zod30.z.looseObject({
+  structure_id: import_zod30.z.number(),
+  moon_id: import_zod30.z.number(),
+  extraction_start_time: import_zod30.z.string(),
+  chunk_arrival_time: import_zod30.z.string(),
+  natural_decay_time: import_zod30.z.string()
+});
+var MiningObserverSchema = import_zod30.z.looseObject({
+  observer_id: import_zod30.z.number(),
+  observer_type: import_zod30.z.string(),
+  last_updated: import_zod30.z.string()
+});
+var MiningObserverEntrySchema = import_zod30.z.looseObject({
+  character_id: import_zod30.z.number(),
+  recorded_corporation_id: import_zod30.z.number(),
+  type_id: import_zod30.z.number(),
+  quantity: import_zod30.z.number(),
+  last_updated: import_zod30.z.string()
 });
 
 // src/core/endpoints/industryEndpoints.ts
@@ -4972,54 +5086,54 @@ var industryEndpoints = {
     method: "GET",
     requiresAuth: true,
     pathParams: ["characterId"],
-    responseSchema: import_zod29.z.array(IndustryJobSchema)
+    responseSchema: import_zod31.z.array(IndustryJobSchema)
   },
   getCharacterMiningLedger: {
     path: "characters/{characterId}/mining",
     method: "GET",
     requiresAuth: true,
     pathParams: ["characterId"],
-    responseSchema: import_zod29.z.array(MiningLedgerEntrySchema)
+    responseSchema: import_zod31.z.array(MiningLedgerEntrySchema)
   },
   getCorporationIndustryJobs: {
     path: "corporations/{corporationId}/industry/jobs",
     method: "GET",
     requiresAuth: true,
     pathParams: ["corporationId"],
-    responseSchema: import_zod29.z.array(IndustryJobSchema)
+    responseSchema: import_zod31.z.array(IndustryJobSchema)
   },
   getMoonExtractionTimers: {
-    path: "corporations/{corporationId}/mining/extractions",
+    path: "corporation/{corporationId}/mining/extractions",
     method: "GET",
     requiresAuth: true,
     pathParams: ["corporationId"],
-    responseSchema: import_zod29.z.array(MoonExtractionTimerSchema)
+    responseSchema: import_zod31.z.array(MoonExtractionTimerSchema)
   },
   getCorporationMiningObservers: {
-    path: "corporations/{corporationId}/mining/observers",
+    path: "corporation/{corporationId}/mining/observers",
     method: "GET",
     requiresAuth: true,
     pathParams: ["corporationId"],
-    responseSchema: import_zod29.z.array(MiningObserverSchema)
+    responseSchema: import_zod31.z.array(MiningObserverSchema)
   },
   getCorporationMiningObserver: {
-    path: "corporations/{corporationId}/mining/observers/{observerId}",
+    path: "corporation/{corporationId}/mining/observers/{observerId}",
     method: "GET",
     requiresAuth: true,
     pathParams: ["corporationId", "observerId"],
-    responseSchema: import_zod29.z.array(MiningObserverEntrySchema)
+    responseSchema: import_zod31.z.array(MiningObserverEntrySchema)
   },
   getIndustryFacilities: {
     path: "industry/facilities",
     method: "GET",
     requiresAuth: false,
-    responseSchema: import_zod29.z.array(IndustryFacilitySchema)
+    responseSchema: import_zod31.z.array(IndustryFacilitySchema)
   },
   getIndustrySystems: {
     path: "industry/systems",
     method: "GET",
     requiresAuth: false,
-    responseSchema: import_zod29.z.array(IndustrySystemSchema)
+    responseSchema: import_zod31.z.array(IndustrySystemSchema)
   }
 };
 
@@ -5151,17 +5265,17 @@ var IndustryClient = class extends BaseEsiClient {
 };
 
 // src/core/endpoints/insuranceEndpoints.ts
-var import_zod31 = require("zod");
+var import_zod33 = require("zod");
 
 // src/schemas/insurance.ts
-var import_zod30 = require("zod");
-var InsurancePriceSchema = import_zod30.z.looseObject({
-  type_id: import_zod30.z.number(),
-  levels: import_zod30.z.array(
-    import_zod30.z.looseObject({
-      cost: import_zod30.z.number(),
-      payout: import_zod30.z.number(),
-      name: import_zod30.z.string()
+var import_zod32 = require("zod");
+var InsurancePriceSchema = import_zod32.z.looseObject({
+  type_id: import_zod32.z.number(),
+  levels: import_zod32.z.array(
+    import_zod32.z.looseObject({
+      cost: import_zod32.z.number(),
+      payout: import_zod32.z.number(),
+      name: import_zod32.z.string()
     })
   )
 });
@@ -5172,7 +5286,7 @@ var insuranceEndpoints = {
     path: "insurance/prices",
     method: "GET",
     requiresAuth: false,
-    responseSchema: import_zod31.z.array(InsurancePriceSchema)
+    responseSchema: import_zod33.z.array(InsurancePriceSchema)
   }
 };
 
@@ -5192,45 +5306,45 @@ var InsuranceClient = class extends BaseEsiClient {
 };
 
 // src/core/endpoints/killmailEndpoints.ts
-var import_zod33 = require("zod");
+var import_zod35 = require("zod");
 
 // src/schemas/killmails.ts
-var import_zod32 = require("zod");
-var KillmailSummarySchema = import_zod32.z.looseObject({
-  killmail_id: import_zod32.z.number(),
-  killmail_hash: import_zod32.z.string()
-});
-var KillmailSchema = import_zod32.z.looseObject({
-  killmail_id: import_zod32.z.number(),
-  killmail_time: import_zod32.z.string(),
-  solar_system_id: import_zod32.z.number(),
-  moon_id: import_zod32.z.number().optional(),
-  war_id: import_zod32.z.number().optional(),
-  victim: import_zod32.z.looseObject({
-    character_id: import_zod32.z.number().optional(),
-    corporation_id: import_zod32.z.number().optional(),
-    alliance_id: import_zod32.z.number().optional(),
-    faction_id: import_zod32.z.number().optional(),
-    ship_type_id: import_zod32.z.number(),
-    damage_taken: import_zod32.z.number(),
-    position: import_zod32.z.looseObject({
-      x: import_zod32.z.number(),
-      y: import_zod32.z.number(),
-      z: import_zod32.z.number()
+var import_zod34 = require("zod");
+var KillmailSummarySchema = import_zod34.z.looseObject({
+  killmail_id: import_zod34.z.number(),
+  killmail_hash: import_zod34.z.string()
+});
+var KillmailSchema = import_zod34.z.looseObject({
+  killmail_id: import_zod34.z.number(),
+  killmail_time: import_zod34.z.string(),
+  solar_system_id: import_zod34.z.number(),
+  moon_id: import_zod34.z.number().optional(),
+  war_id: import_zod34.z.number().optional(),
+  victim: import_zod34.z.looseObject({
+    character_id: import_zod34.z.number().optional(),
+    corporation_id: import_zod34.z.number().optional(),
+    alliance_id: import_zod34.z.number().optional(),
+    faction_id: import_zod34.z.number().optional(),
+    ship_type_id: import_zod34.z.number(),
+    damage_taken: import_zod34.z.number(),
+    position: import_zod34.z.looseObject({
+      x: import_zod34.z.number(),
+      y: import_zod34.z.number(),
+      z: import_zod34.z.number()
     }).optional(),
-    items: import_zod32.z.array(import_zod32.z.unknown()).optional()
+    items: import_zod34.z.array(import_zod34.z.unknown()).optional()
   }),
-  attackers: import_zod32.z.array(
-    import_zod32.z.looseObject({
-      character_id: import_zod32.z.number().optional(),
-      corporation_id: import_zod32.z.number().optional(),
-      alliance_id: import_zod32.z.number().optional(),
-      faction_id: import_zod32.z.number().optional(),
-      ship_type_id: import_zod32.z.number().optional(),
-      weapon_type_id: import_zod32.z.number().optional(),
-      damage_done: import_zod32.z.number(),
-      final_blow: import_zod32.z.boolean(),
-      security_status: import_zod32.z.number()
+  attackers: import_zod34.z.array(
+    import_zod34.z.looseObject({
+      character_id: import_zod34.z.number().optional(),
+      corporation_id: import_zod34.z.number().optional(),
+      alliance_id: import_zod34.z.number().optional(),
+      faction_id: import_zod34.z.number().optional(),
+      ship_type_id: import_zod34.z.number().optional(),
+      weapon_type_id: import_zod34.z.number().optional(),
+      damage_done: import_zod34.z.number(),
+      final_blow: import_zod34.z.boolean(),
+      security_status: import_zod34.z.number()
     })
   )
 });
@@ -5242,14 +5356,14 @@ var killmailEndpoints = {
     method: "GET",
     requiresAuth: true,
     pathParams: ["characterId"],
-    responseSchema: import_zod33.z.array(KillmailSummarySchema)
+    responseSchema: import_zod35.z.array(KillmailSummarySchema)
   },
   getCorporationRecentKillmails: {
     path: "corporations/{corporationId}/killmails/recent",
     method: "GET",
     requiresAuth: true,
     pathParams: ["corporationId"],
-    responseSchema: import_zod33.z.array(KillmailSummarySchema)
+    responseSchema: import_zod35.z.array(KillmailSummarySchema)
   },
   getKillmail: {
     path: "killmails/{killmailId}/{killmailHash}",
@@ -5310,22 +5424,22 @@ var KillmailsClient = class extends BaseEsiClient {
 };
 
 // src/schemas/location.ts
-var import_zod34 = require("zod");
-var CharacterLocationSchema = import_zod34.z.looseObject({
-  solar_system_id: import_zod34.z.number(),
-  station_id: import_zod34.z.number().optional(),
-  structure_id: import_zod34.z.number().optional()
+var import_zod36 = require("zod");
+var CharacterLocationSchema = import_zod36.z.looseObject({
+  solar_system_id: import_zod36.z.number(),
+  station_id: import_zod36.z.number().optional(),
+  structure_id: import_zod36.z.number().optional()
 });
-var CharacterOnlineSchema = import_zod34.z.looseObject({
-  online: import_zod34.z.boolean(),
-  last_login: import_zod34.z.string().optional(),
-  last_logout: import_zod34.z.string().optional(),
-  logins: import_zod34.z.number().optional()
+var CharacterOnlineSchema = import_zod36.z.looseObject({
+  online: import_zod36.z.boolean(),
+  last_login: import_zod36.z.string().optional(),
+  last_logout: import_zod36.z.string().optional(),
+  logins: import_zod36.z.number().optional()
 });
-var CharacterShipSchema = import_zod34.z.looseObject({
-  ship_item_id: import_zod34.z.number(),
-  ship_name: import_zod34.z.string(),
-  ship_type_id: import_zod34.z.number()
+var CharacterShipSchema = import_zod36.z.looseObject({
+  ship_item_id: import_zod36.z.number(),
+  ship_name: import_zod36.z.string(),
+  ship_type_id: import_zod36.z.number()
 });
 
 // src/core/endpoints/locationEndpoints.ts
@@ -5393,25 +5507,25 @@ var LocationClient = class extends BaseEsiClient {
 };
 
 // src/core/endpoints/loyaltyEndpoints.ts
-var import_zod36 = require("zod");
+var import_zod38 = require("zod");
 
 // src/schemas/loyalty.ts
-var import_zod35 = require("zod");
-var LoyaltyPointsSchema = import_zod35.z.looseObject({
-  corporation_id: import_zod35.z.number(),
-  loyalty_points: import_zod35.z.number()
-});
-var LoyaltyStoreOfferSchema = import_zod35.z.looseObject({
-  offer_id: import_zod35.z.number(),
-  type_id: import_zod35.z.number(),
-  quantity: import_zod35.z.number(),
-  lp_cost: import_zod35.z.number(),
-  isk_cost: import_zod35.z.number(),
-  ak_cost: import_zod35.z.number().optional(),
-  required_items: import_zod35.z.array(
-    import_zod35.z.looseObject({
-      type_id: import_zod35.z.number(),
-      quantity: import_zod35.z.number()
+var import_zod37 = require("zod");
+var LoyaltyPointsSchema = import_zod37.z.looseObject({
+  corporation_id: import_zod37.z.number(),
+  loyalty_points: import_zod37.z.number()
+});
+var LoyaltyStoreOfferSchema = import_zod37.z.looseObject({
+  offer_id: import_zod37.z.number(),
+  type_id: import_zod37.z.number(),
+  quantity: import_zod37.z.number(),
+  lp_cost: import_zod37.z.number(),
+  isk_cost: import_zod37.z.number(),
+  ak_cost: import_zod37.z.number().optional(),
+  required_items: import_zod37.z.array(
+    import_zod37.z.looseObject({
+      type_id: import_zod37.z.number(),
+      quantity: import_zod37.z.number()
     })
   )
 });
@@ -5423,14 +5537,14 @@ var loyaltyEndpoints = {
     method: "GET",
     requiresAuth: true,
     pathParams: ["characterId"],
-    responseSchema: import_zod36.z.array(LoyaltyPointsSchema)
+    responseSchema: import_zod38.z.array(LoyaltyPointsSchema)
   },
   getLoyaltyStoreOffers: {
     path: "loyalty/stores/{corporationId}/offers",
     method: "GET",
     requiresAuth: false,
     pathParams: ["corporationId"],
-    responseSchema: import_zod36.z.array(LoyaltyStoreOfferSchema)
+    responseSchema: import_zod38.z.array(LoyaltyStoreOfferSchema)
   }
 };
 
@@ -5470,22 +5584,22 @@ var LoyaltyClient = class extends BaseEsiClient {
 };
 
 // src/core/endpoints/mailEndpoints.ts
-var import_zod38 = require("zod");
+var import_zod40 = require("zod");
 
 // src/schemas/mail.ts
-var import_zod37 = require("zod");
-var MailMessageSchema = import_zod37.z.looseObject({
-  mail_id: import_zod37.z.number().optional(),
-  subject: import_zod37.z.string().optional(),
-  from: import_zod37.z.number().optional(),
-  timestamp: import_zod37.z.string().optional(),
-  labels: import_zod37.z.array(import_zod37.z.number()).optional(),
-  is_read: import_zod37.z.boolean().optional(),
-  body: import_zod37.z.string().optional(),
-  recipients: import_zod37.z.array(
-    import_zod37.z.looseObject({
-      recipient_id: import_zod37.z.number(),
-      recipient_type: import_zod37.z.enum([
+var import_zod39 = require("zod");
+var MailMessageSchema = import_zod39.z.looseObject({
+  mail_id: import_zod39.z.number().optional(),
+  subject: import_zod39.z.string().optional(),
+  from: import_zod39.z.number().optional(),
+  timestamp: import_zod39.z.string().optional(),
+  labels: import_zod39.z.array(import_zod39.z.number()).optional(),
+  is_read: import_zod39.z.boolean().optional(),
+  body: import_zod39.z.string().optional(),
+  recipients: import_zod39.z.array(
+    import_zod39.z.looseObject({
+      recipient_id: import_zod39.z.number(),
+      recipient_type: import_zod39.z.enum([
         "alliance",
         "character",
         "corporation",
@@ -5494,19 +5608,19 @@ var MailMessageSchema = import_zod37.z.looseObject({
     })
   ).optional()
 });
-var MailLabelSchema = import_zod37.z.looseObject({
-  label_id: import_zod37.z.number(),
-  name: import_zod37.z.string(),
-  color: import_zod37.z.string().optional(),
-  unread_count: import_zod37.z.number().optional()
+var MailLabelSchema = import_zod39.z.looseObject({
+  label_id: import_zod39.z.number(),
+  name: import_zod39.z.string(),
+  color: import_zod39.z.string().optional(),
+  unread_count: import_zod39.z.number().optional()
 });
-var MailLabelsResponseSchema = import_zod37.z.looseObject({
-  labels: import_zod37.z.array(MailLabelSchema).optional(),
-  total_unread_count: import_zod37.z.number().optional()
+var MailLabelsResponseSchema = import_zod39.z.looseObject({
+  labels: import_zod39.z.array(MailLabelSchema).optional(),
+  total_unread_count: import_zod39.z.number().optional()
 });
-var MailingListSchema = import_zod37.z.looseObject({
-  mailing_list_id: import_zod37.z.number(),
-  name: import_zod37.z.string()
+var MailingListSchema = import_zod39.z.looseObject({
+  mailing_list_id: import_zod39.z.number(),
+  name: import_zod39.z.string()
 });
 
 // src/core/endpoints/mailEndpoints.ts
@@ -5516,7 +5630,7 @@ var mailEndpoints = {
     method: "GET",
     requiresAuth: true,
     pathParams: ["characterId"],
-    responseSchema: import_zod38.z.array(MailMessageSchema)
+    responseSchema: import_zod40.z.array(MailMessageSchema)
   },
   sendMail: {
     path: "characters/{characterId}/mail/",
@@ -5524,11 +5638,11 @@ var mailEndpoints = {
     requiresAuth: true,
     pathParams: ["characterId"],
     hasBody: true,
-    requestSchema: import_zod38.z.looseObject({
-      recipients: import_zod38.z.array(
-        import_zod38.z.looseObject({
-          recipient_id: import_zod38.z.number().int(),
-          recipient_type: import_zod38.z.enum([
+    requestSchema: import_zod40.z.looseObject({
+      recipients: import_zod40.z.array(
+        import_zod40.z.looseObject({
+          recipient_id: import_zod40.z.number().int(),
+          recipient_type: import_zod40.z.enum([
             "alliance",
             "character",
             "corporation",
@@ -5536,8 +5650,8 @@ var mailEndpoints = {
           ])
         })
       ),
-      subject: import_zod38.z.string().min(1),
-      body: import_zod38.z.string().min(1)
+      subject: import_zod40.z.string().min(1),
+      body: import_zod40.z.string().min(1)
     })
   },
   getMail: {
@@ -5585,7 +5699,7 @@ var mailEndpoints = {
     method: "GET",
     requiresAuth: true,
     pathParams: ["characterId"],
-    responseSchema: import_zod38.z.array(MailingListSchema)
+    responseSchema: import_zod40.z.array(MailingListSchema)
   }
 };
 
@@ -5710,124 +5824,124 @@ var MailClient = class extends BaseEsiClient {
 };
 
 // src/core/endpoints/marketEndpoints.ts
-var import_zod40 = require("zod");
+var import_zod42 = require("zod");
 
 // src/schemas/market.ts
-var import_zod39 = require("zod");
-var MarketOrderSchema = import_zod39.z.looseObject({
-  order_id: import_zod39.z.number(),
-  type_id: import_zod39.z.number(),
-  location_id: import_zod39.z.number(),
-  volume_total: import_zod39.z.number(),
-  volume_remain: import_zod39.z.number(),
-  min_volume: import_zod39.z.number(),
-  price: import_zod39.z.number(),
-  is_buy_order: import_zod39.z.boolean(),
-  system_id: import_zod39.z.number(),
-  duration: import_zod39.z.number(),
-  issued: import_zod39.z.string(),
-  range: import_zod39.z.string()
-});
-var CharacterMarketOrderSchema = import_zod39.z.looseObject({
-  order_id: import_zod39.z.number(),
-  type_id: import_zod39.z.number(),
-  location_id: import_zod39.z.number(),
-  volume_total: import_zod39.z.number(),
-  volume_remain: import_zod39.z.number(),
-  min_volume: import_zod39.z.number().optional(),
-  price: import_zod39.z.number(),
-  is_buy_order: import_zod39.z.boolean().optional(),
-  is_corporation: import_zod39.z.boolean(),
-  region_id: import_zod39.z.number(),
-  duration: import_zod39.z.number(),
-  issued: import_zod39.z.string(),
-  range: import_zod39.z.string(),
-  escrow: import_zod39.z.number().optional()
-});
-var CharacterMarketOrderHistorySchema = import_zod39.z.looseObject({
-  order_id: import_zod39.z.number(),
-  type_id: import_zod39.z.number(),
-  location_id: import_zod39.z.number(),
-  volume_total: import_zod39.z.number(),
-  volume_remain: import_zod39.z.number(),
-  min_volume: import_zod39.z.number().optional(),
-  price: import_zod39.z.number(),
-  is_buy_order: import_zod39.z.boolean().optional(),
-  is_corporation: import_zod39.z.boolean(),
-  region_id: import_zod39.z.number(),
-  duration: import_zod39.z.number(),
-  issued: import_zod39.z.string(),
-  range: import_zod39.z.string(),
-  state: import_zod39.z.enum(["cancelled", "expired"]),
-  escrow: import_zod39.z.number().optional()
-});
-var CorporationMarketOrderSchema = import_zod39.z.looseObject({
-  order_id: import_zod39.z.number(),
-  type_id: import_zod39.z.number(),
-  location_id: import_zod39.z.number(),
-  volume_total: import_zod39.z.number(),
-  volume_remain: import_zod39.z.number(),
-  min_volume: import_zod39.z.number().optional(),
-  price: import_zod39.z.number(),
-  is_buy_order: import_zod39.z.boolean().optional(),
-  issued_by: import_zod39.z.number(),
-  region_id: import_zod39.z.number(),
-  wallet_division: import_zod39.z.number(),
-  duration: import_zod39.z.number(),
-  issued: import_zod39.z.string(),
-  range: import_zod39.z.string(),
-  escrow: import_zod39.z.number().optional()
-});
-var CorporationMarketOrderHistorySchema = import_zod39.z.looseObject({
-  order_id: import_zod39.z.number(),
-  type_id: import_zod39.z.number(),
-  location_id: import_zod39.z.number(),
-  volume_total: import_zod39.z.number(),
-  volume_remain: import_zod39.z.number(),
-  min_volume: import_zod39.z.number().optional(),
-  price: import_zod39.z.number(),
-  is_buy_order: import_zod39.z.boolean().optional(),
-  issued_by: import_zod39.z.number().optional(),
-  region_id: import_zod39.z.number(),
-  wallet_division: import_zod39.z.number(),
-  duration: import_zod39.z.number(),
-  issued: import_zod39.z.string(),
-  range: import_zod39.z.string(),
-  state: import_zod39.z.enum(["cancelled", "expired"]),
-  escrow: import_zod39.z.number().optional()
-});
-var StructureMarketOrderSchema = import_zod39.z.looseObject({
-  order_id: import_zod39.z.number(),
-  type_id: import_zod39.z.number(),
-  location_id: import_zod39.z.number(),
-  volume_total: import_zod39.z.number(),
-  volume_remain: import_zod39.z.number(),
-  min_volume: import_zod39.z.number(),
-  price: import_zod39.z.number(),
-  is_buy_order: import_zod39.z.boolean(),
-  duration: import_zod39.z.number(),
-  issued: import_zod39.z.string(),
-  range: import_zod39.z.string()
-});
-var MarketHistorySchema = import_zod39.z.looseObject({
-  date: import_zod39.z.string(),
-  order_count: import_zod39.z.number(),
-  volume: import_zod39.z.number(),
-  highest: import_zod39.z.number(),
-  average: import_zod39.z.number(),
-  lowest: import_zod39.z.number()
-});
-var MarketGroupSchema = import_zod39.z.looseObject({
-  market_group_id: import_zod39.z.number(),
-  name: import_zod39.z.string(),
-  description: import_zod39.z.string(),
-  types: import_zod39.z.array(import_zod39.z.number()),
-  parent_group_id: import_zod39.z.number().optional()
-});
-var MarketPriceSchema = import_zod39.z.looseObject({
-  type_id: import_zod39.z.number(),
-  average_price: import_zod39.z.number().optional(),
-  adjusted_price: import_zod39.z.number().optional()
+var import_zod41 = require("zod");
+var MarketOrderSchema = import_zod41.z.looseObject({
+  order_id: import_zod41.z.number(),
+  type_id: import_zod41.z.number(),
+  location_id: import_zod41.z.number(),
+  volume_total: import_zod41.z.number(),
+  volume_remain: import_zod41.z.number(),
+  min_volume: import_zod41.z.number(),
+  price: import_zod41.z.number(),
+  is_buy_order: import_zod41.z.boolean(),
+  system_id: import_zod41.z.number(),
+  duration: import_zod41.z.number(),
+  issued: import_zod41.z.string(),
+  range: import_zod41.z.string()
+});
+var CharacterMarketOrderSchema = import_zod41.z.looseObject({
+  order_id: import_zod41.z.number(),
+  type_id: import_zod41.z.number(),
+  location_id: import_zod41.z.number(),
+  volume_total: import_zod41.z.number(),
+  volume_remain: import_zod41.z.number(),
+  min_volume: import_zod41.z.number().optional(),
+  price: import_zod41.z.number(),
+  is_buy_order: import_zod41.z.boolean().optional(),
+  is_corporation: import_zod41.z.boolean(),
+  region_id: import_zod41.z.number(),
+  duration: import_zod41.z.number(),
+  issued: import_zod41.z.string(),
+  range: import_zod41.z.string(),
+  escrow: import_zod41.z.number().optional()
+});
+var CharacterMarketOrderHistorySchema = import_zod41.z.looseObject({
+  order_id: import_zod41.z.number(),
+  type_id: import_zod41.z.number(),
+  location_id: import_zod41.z.number(),
+  volume_total: import_zod41.z.number(),
+  volume_remain: import_zod41.z.number(),
+  min_volume: import_zod41.z.number().optional(),
+  price: import_zod41.z.number(),
+  is_buy_order: import_zod41.z.boolean().optional(),
+  is_corporation: import_zod41.z.boolean(),
+  region_id: import_zod41.z.number(),
+  duration: import_zod41.z.number(),
+  issued: import_zod41.z.string(),
+  range: import_zod41.z.string(),
+  state: import_zod41.z.enum(["cancelled", "expired"]),
+  escrow: import_zod41.z.number().optional()
+});
+var CorporationMarketOrderSchema = import_zod41.z.looseObject({
+  order_id: import_zod41.z.number(),
+  type_id: import_zod41.z.number(),
+  location_id: import_zod41.z.number(),
+  volume_total: import_zod41.z.number(),
+  volume_remain: import_zod41.z.number(),
+  min_volume: import_zod41.z.number().optional(),
+  price: import_zod41.z.number(),
+  is_buy_order: import_zod41.z.boolean().optional(),
+  issued_by: import_zod41.z.number(),
+  region_id: import_zod41.z.number(),
+  wallet_division: import_zod41.z.number(),
+  duration: import_zod41.z.number(),
+  issued: import_zod41.z.string(),
+  range: import_zod41.z.string(),
+  escrow: import_zod41.z.number().optional()
+});
+var CorporationMarketOrderHistorySchema = import_zod41.z.looseObject({
+  order_id: import_zod41.z.number(),
+  type_id: import_zod41.z.number(),
+  location_id: import_zod41.z.number(),
+  volume_total: import_zod41.z.number(),
+  volume_remain: import_zod41.z.number(),
+  min_volume: import_zod41.z.number().optional(),
+  price: import_zod41.z.number(),
+  is_buy_order: import_zod41.z.boolean().optional(),
+  issued_by: import_zod41.z.number().optional(),
+  region_id: import_zod41.z.number(),
+  wallet_division: import_zod41.z.number(),
+  duration: import_zod41.z.number(),
+  issued: import_zod41.z.string(),
+  range: import_zod41.z.string(),
+  state: import_zod41.z.enum(["cancelled", "expired"]),
+  escrow: import_zod41.z.number().optional()
+});
+var StructureMarketOrderSchema = import_zod41.z.looseObject({
+  order_id: import_zod41.z.number(),
+  type_id: import_zod41.z.number(),
+  location_id: import_zod41.z.number(),
+  volume_total: import_zod41.z.number(),
+  volume_remain: import_zod41.z.number(),
+  min_volume: import_zod41.z.number(),
+  price: import_zod41.z.number(),
+  is_buy_order: import_zod41.z.boolean(),
+  duration: import_zod41.z.number(),
+  issued: import_zod41.z.string(),
+  range: import_zod41.z.string()
+});
+var MarketHistorySchema = import_zod41.z.looseObject({
+  date: import_zod41.z.string(),
+  order_count: import_zod41.z.number(),
+  volume: import_zod41.z.number(),
+  highest: import_zod41.z.number(),
+  average: import_zod41.z.number(),
+  lowest: import_zod41.z.number()
+});
+var MarketGroupSchema = import_zod41.z.looseObject({
+  market_group_id: import_zod41.z.number(),
+  name: import_zod41.z.string(),
+  description: import_zod41.z.string(),
+  types: import_zod41.z.array(import_zod41.z.number()),
+  parent_group_id: import_zod41.z.number().optional()
+});
+var MarketPriceSchema = import_zod41.z.looseObject({
+  type_id: import_zod41.z.number(),
+  average_price: import_zod41.z.number().optional(),
+  adjusted_price: import_zod41.z.number().optional()
 });
 
 // src/core/endpoints/marketEndpoints.ts
@@ -5837,34 +5951,34 @@ var marketEndpoints = {
     method: "GET",
     requiresAuth: true,
     pathParams: ["characterId"],
-    responseSchema: import_zod40.z.array(CharacterMarketOrderSchema)
+    responseSchema: import_zod42.z.array(CharacterMarketOrderSchema)
   },
   getCharacterOrderHistory: {
     path: "characters/{characterId}/orders/history/",
     method: "GET",
     requiresAuth: true,
     pathParams: ["characterId"],
-    responseSchema: import_zod40.z.array(CharacterMarketOrderHistorySchema)
+    responseSchema: import_zod42.z.array(CharacterMarketOrderHistorySchema)
   },
   getCorporationOrders: {
     path: "corporations/{corporationId}/orders/",
     method: "GET",
     requiresAuth: true,
     pathParams: ["corporationId"],
-    responseSchema: import_zod40.z.array(CorporationMarketOrderSchema)
+    responseSchema: import_zod42.z.array(CorporationMarketOrderSchema)
   },
   getCorporationOrderHistory: {
     path: "corporations/{corporationId}/orders/history/",
     method: "GET",
     requiresAuth: true,
     pathParams: ["corporationId"],
-    responseSchema: import_zod40.z.array(CorporationMarketOrderHistorySchema)
+    responseSchema: import_zod42.z.array(CorporationMarketOrderHistorySchema)
   },
   getMarketGroups: {
     path: "markets/groups/",
     method: "GET",
     requiresAuth: false,
-    responseSchema: import_zod40.z.array(import_zod40.z.number())
+    responseSchema: import_zod42.z.array(import_zod42.z.number())
   },
   getMarketGroupInformation: {
     path: "markets/groups/{marketGroupId}/",
@@ -5877,14 +5991,14 @@ var marketEndpoints = {
     path: "markets/prices/",
     method: "GET",
     requiresAuth: false,
-    responseSchema: import_zod40.z.array(MarketPriceSchema)
+    responseSchema: import_zod42.z.array(MarketPriceSchema)
   },
   getMarketOrdersInStructure: {
     path: "markets/structures/{structureId}/",
     method: "GET",
     requiresAuth: true,
     pathParams: ["structureId"],
-    responseSchema: import_zod40.z.array(StructureMarketOrderSchema)
+    responseSchema: import_zod42.z.array(StructureMarketOrderSchema)
   },
   getMarketHistory: {
     path: "markets/{regionId}/history/",
@@ -5892,7 +6006,7 @@ var marketEndpoints = {
     requiresAuth: false,
     pathParams: ["regionId"],
     queryParams: { typeId: "type_id" },
-    responseSchema: import_zod40.z.array(MarketHistorySchema)
+    responseSchema: import_zod42.z.array(MarketHistorySchema)
   },
   getMarketOrders: {
     path: "markets/{regionId}/orders/",
@@ -5900,14 +6014,14 @@ var marketEndpoints = {
     requiresAuth: false,
     pathParams: ["regionId"],
     queryParams: { orderType: "order_type" },
-    responseSchema: import_zod40.z.array(MarketOrderSchema)
+    responseSchema: import_zod42.z.array(MarketOrderSchema)
   },
   getMarketTypes: {
     path: "markets/{regionId}/types/",
     method: "GET",
     requiresAuth: false,
     pathParams: ["regionId"],
-    responseSchema: import_zod40.z.array(import_zod40.z.number())
+    responseSchema: import_zod42.z.array(import_zod42.z.number())
   }
 };
 
@@ -6052,14 +6166,14 @@ var MarketClient = class extends BaseEsiClient {
 };
 
 // src/core/endpoints/piEndpoints.ts
-var import_zod43 = require("zod");
+var import_zod45 = require("zod");
 
 // src/schemas/pi.ts
-var import_zod41 = require("zod");
-var PlanetaryColonySchema = import_zod41.z.looseObject({
-  solar_system_id: import_zod41.z.number(),
-  planet_id: import_zod41.z.number(),
-  planet_type: import_zod41.z.enum([
+var import_zod43 = require("zod");
+var PlanetaryColonySchema = import_zod43.z.looseObject({
+  solar_system_id: import_zod43.z.number(),
+  planet_id: import_zod43.z.number(),
+  planet_type: import_zod43.z.enum([
     "temperate",
     "barren",
     "oceanic",
@@ -6069,302 +6183,302 @@ var PlanetaryColonySchema = import_zod41.z.looseObject({
     "storm",
     "plasma"
   ]),
-  owner_id: import_zod41.z.number(),
-  last_update: import_zod41.z.string(),
-  upgrade_level: import_zod41.z.number(),
-  num_pins: import_zod41.z.number()
-});
-var CustomsOfficeSchema = import_zod41.z.looseObject({
-  office_id: import_zod41.z.number(),
-  system_id: import_zod41.z.number(),
-  reinforce_exit_start: import_zod41.z.number(),
-  reinforce_exit_end: import_zod41.z.number(),
-  allow_access_with_standings: import_zod41.z.boolean().optional(),
-  allow_alliance_access: import_zod41.z.boolean().optional(),
-  alliance_tax_rate: import_zod41.z.number().optional(),
-  corporation_tax_rate: import_zod41.z.number().optional(),
-  standing_level: import_zod41.z.string().optional(),
-  terrible_standing_tax_rate: import_zod41.z.number().optional(),
-  bad_standing_tax_rate: import_zod41.z.number().optional(),
-  neutral_standing_tax_rate: import_zod41.z.number().optional(),
-  good_standing_tax_rate: import_zod41.z.number().optional(),
-  excellent_standing_tax_rate: import_zod41.z.number().optional(),
-  type_id: import_zod41.z.number().optional()
-});
-var ColonyLayoutSchema = import_zod41.z.looseObject({
-  links: import_zod41.z.array(
-    import_zod41.z.looseObject({
-      source_pin_id: import_zod41.z.number(),
-      destination_pin_id: import_zod41.z.number(),
-      link_level: import_zod41.z.number()
+  owner_id: import_zod43.z.number(),
+  last_update: import_zod43.z.string(),
+  upgrade_level: import_zod43.z.number(),
+  num_pins: import_zod43.z.number()
+});
+var CustomsOfficeSchema = import_zod43.z.looseObject({
+  office_id: import_zod43.z.number(),
+  system_id: import_zod43.z.number(),
+  reinforce_exit_start: import_zod43.z.number(),
+  reinforce_exit_end: import_zod43.z.number(),
+  allow_access_with_standings: import_zod43.z.boolean().optional(),
+  allow_alliance_access: import_zod43.z.boolean().optional(),
+  alliance_tax_rate: import_zod43.z.number().optional(),
+  corporation_tax_rate: import_zod43.z.number().optional(),
+  standing_level: import_zod43.z.string().optional(),
+  terrible_standing_tax_rate: import_zod43.z.number().optional(),
+  bad_standing_tax_rate: import_zod43.z.number().optional(),
+  neutral_standing_tax_rate: import_zod43.z.number().optional(),
+  good_standing_tax_rate: import_zod43.z.number().optional(),
+  excellent_standing_tax_rate: import_zod43.z.number().optional(),
+  type_id: import_zod43.z.number().optional()
+});
+var ColonyLayoutSchema = import_zod43.z.looseObject({
+  links: import_zod43.z.array(
+    import_zod43.z.looseObject({
+      source_pin_id: import_zod43.z.number(),
+      destination_pin_id: import_zod43.z.number(),
+      link_level: import_zod43.z.number()
     })
   ),
-  pins: import_zod41.z.array(
-    import_zod41.z.looseObject({
-      pin_id: import_zod41.z.number(),
-      type_id: import_zod41.z.number(),
-      latitude: import_zod41.z.number(),
-      longitude: import_zod41.z.number(),
-      schematic_id: import_zod41.z.number().optional(),
-      extractor_details: import_zod41.z.looseObject({
-        heads: import_zod41.z.array(
-          import_zod41.z.looseObject({
-            head_id: import_zod41.z.number(),
-            latitude: import_zod41.z.number(),
-            longitude: import_zod41.z.number()
+  pins: import_zod43.z.array(
+    import_zod43.z.looseObject({
+      pin_id: import_zod43.z.number(),
+      type_id: import_zod43.z.number(),
+      latitude: import_zod43.z.number(),
+      longitude: import_zod43.z.number(),
+      schematic_id: import_zod43.z.number().optional(),
+      extractor_details: import_zod43.z.looseObject({
+        heads: import_zod43.z.array(
+          import_zod43.z.looseObject({
+            head_id: import_zod43.z.number(),
+            latitude: import_zod43.z.number(),
+            longitude: import_zod43.z.number()
           })
         ),
-        product_type_id: import_zod41.z.number().optional(),
-        cycle_time: import_zod41.z.number().optional(),
-        head_radius: import_zod41.z.number().optional(),
-        qty_per_cycle: import_zod41.z.number().optional()
+        product_type_id: import_zod43.z.number().optional(),
+        cycle_time: import_zod43.z.number().optional(),
+        head_radius: import_zod43.z.number().optional(),
+        qty_per_cycle: import_zod43.z.number().optional()
       }).optional(),
-      factory_details: import_zod41.z.looseObject({
-        schematic_id: import_zod41.z.number()
+      factory_details: import_zod43.z.looseObject({
+        schematic_id: import_zod43.z.number()
       }).optional(),
-      contents: import_zod41.z.array(
-        import_zod41.z.looseObject({
-          type_id: import_zod41.z.number(),
-          amount: import_zod41.z.number()
+      contents: import_zod43.z.array(
+        import_zod43.z.looseObject({
+          type_id: import_zod43.z.number(),
+          amount: import_zod43.z.number()
         })
       ).optional(),
-      install_time: import_zod41.z.string().optional(),
-      expiry_time: import_zod41.z.string().optional(),
-      last_cycle_start: import_zod41.z.string().optional()
+      install_time: import_zod43.z.string().optional(),
+      expiry_time: import_zod43.z.string().optional(),
+      last_cycle_start: import_zod43.z.string().optional()
     })
   ),
-  routes: import_zod41.z.array(
-    import_zod41.z.looseObject({
-      route_id: import_zod41.z.number(),
-      source_pin_id: import_zod41.z.number(),
-      destination_pin_id: import_zod41.z.number(),
-      content_type_id: import_zod41.z.number(),
-      quantity: import_zod41.z.number(),
-      waypoints: import_zod41.z.array(import_zod41.z.number()).optional()
+  routes: import_zod43.z.array(
+    import_zod43.z.looseObject({
+      route_id: import_zod43.z.number(),
+      source_pin_id: import_zod43.z.number(),
+      destination_pin_id: import_zod43.z.number(),
+      content_type_id: import_zod43.z.number(),
+      quantity: import_zod43.z.number(),
+      waypoints: import_zod43.z.array(import_zod43.z.number()).optional()
     })
   )
 });
 
 // src/schemas/universe.ts
-var import_zod42 = require("zod");
-var PositionSchema = import_zod42.z.looseObject({
-  x: import_zod42.z.number(),
-  y: import_zod42.z.number(),
-  z: import_zod42.z.number()
-});
-var SolarSystemInfoSchema = import_zod42.z.looseObject({
-  system_id: import_zod42.z.number(),
-  name: import_zod42.z.string(),
-  constellation_id: import_zod42.z.number(),
+var import_zod44 = require("zod");
+var PositionSchema = import_zod44.z.looseObject({
+  x: import_zod44.z.number(),
+  y: import_zod44.z.number(),
+  z: import_zod44.z.number()
+});
+var SolarSystemInfoSchema = import_zod44.z.looseObject({
+  system_id: import_zod44.z.number(),
+  name: import_zod44.z.string(),
+  constellation_id: import_zod44.z.number(),
   position: PositionSchema.optional(),
-  security_class: import_zod42.z.string().optional(),
-  security_status: import_zod42.z.number(),
-  star_id: import_zod42.z.number().optional(),
-  stargates: import_zod42.z.array(import_zod42.z.number()).optional(),
-  stations: import_zod42.z.array(import_zod42.z.number()).optional(),
-  planets: import_zod42.z.array(
-    import_zod42.z.looseObject({
-      asteroid_belts: import_zod42.z.array(import_zod42.z.number()).optional(),
-      moons: import_zod42.z.array(import_zod42.z.number()).optional(),
-      planet_id: import_zod42.z.number()
+  security_class: import_zod44.z.string().optional(),
+  security_status: import_zod44.z.number(),
+  star_id: import_zod44.z.number().optional(),
+  stargates: import_zod44.z.array(import_zod44.z.number()).optional(),
+  stations: import_zod44.z.array(import_zod44.z.number()).optional(),
+  planets: import_zod44.z.array(
+    import_zod44.z.looseObject({
+      asteroid_belts: import_zod44.z.array(import_zod44.z.number()).optional(),
+      moons: import_zod44.z.array(import_zod44.z.number()).optional(),
+      planet_id: import_zod44.z.number()
     })
   ).optional()
 });
-var ConstellationInfoSchema = import_zod42.z.looseObject({
-  constellation_id: import_zod42.z.number(),
-  name: import_zod42.z.string(),
-  region_id: import_zod42.z.number(),
-  systems: import_zod42.z.array(import_zod42.z.number()),
+var ConstellationInfoSchema = import_zod44.z.looseObject({
+  constellation_id: import_zod44.z.number(),
+  name: import_zod44.z.string(),
+  region_id: import_zod44.z.number(),
+  systems: import_zod44.z.array(import_zod44.z.number()),
   position: PositionSchema
 });
-var RegionInfoSchema = import_zod42.z.looseObject({
-  region_id: import_zod42.z.number(),
-  name: import_zod42.z.string(),
-  description: import_zod42.z.string().optional(),
-  constellations: import_zod42.z.array(import_zod42.z.number())
-});
-var AncestrySchema = import_zod42.z.looseObject({
-  id: import_zod42.z.number(),
-  name: import_zod42.z.string(),
-  bloodline_id: import_zod42.z.number(),
-  description: import_zod42.z.string(),
-  short_description: import_zod42.z.string().optional(),
-  icon_id: import_zod42.z.number().optional()
-});
-var BloodlineSchema = import_zod42.z.looseObject({
-  bloodline_id: import_zod42.z.number(),
-  name: import_zod42.z.string(),
-  description: import_zod42.z.string(),
-  race_id: import_zod42.z.number(),
-  corporation_id: import_zod42.z.number(),
-  ship_type_id: import_zod42.z.number().nullable(),
-  charisma: import_zod42.z.number(),
-  intelligence: import_zod42.z.number(),
-  memory: import_zod42.z.number(),
-  perception: import_zod42.z.number(),
-  willpower: import_zod42.z.number()
-});
-var FactionSchema = import_zod42.z.looseObject({
-  faction_id: import_zod42.z.number(),
-  name: import_zod42.z.string(),
-  description: import_zod42.z.string(),
-  size_factor: import_zod42.z.number(),
-  station_count: import_zod42.z.number(),
-  station_system_count: import_zod42.z.number(),
-  is_unique: import_zod42.z.boolean(),
-  solar_system_id: import_zod42.z.number().optional(),
-  corporation_id: import_zod42.z.number().optional(),
-  militia_corporation_id: import_zod42.z.number().optional()
-});
-var RaceSchema = import_zod42.z.looseObject({
-  race_id: import_zod42.z.number(),
-  name: import_zod42.z.string(),
-  description: import_zod42.z.string(),
-  alliance_id: import_zod42.z.number()
-});
-var StationInfoSchema = import_zod42.z.looseObject({
-  station_id: import_zod42.z.number(),
-  name: import_zod42.z.string(),
-  owner: import_zod42.z.number().optional(),
-  system_id: import_zod42.z.number(),
-  type_id: import_zod42.z.number(),
-  race_id: import_zod42.z.number().optional(),
-  reprocessing_efficiency: import_zod42.z.number(),
-  reprocessing_stations_take: import_zod42.z.number(),
-  max_dockable_ship_volume: import_zod42.z.number(),
-  office_rental_cost: import_zod42.z.number(),
-  services: import_zod42.z.array(import_zod42.z.string()),
+var RegionInfoSchema = import_zod44.z.looseObject({
+  region_id: import_zod44.z.number(),
+  name: import_zod44.z.string(),
+  description: import_zod44.z.string().optional(),
+  constellations: import_zod44.z.array(import_zod44.z.number())
+});
+var AncestrySchema = import_zod44.z.looseObject({
+  id: import_zod44.z.number(),
+  name: import_zod44.z.string(),
+  bloodline_id: import_zod44.z.number(),
+  description: import_zod44.z.string(),
+  short_description: import_zod44.z.string().optional(),
+  icon_id: import_zod44.z.number().optional()
+});
+var BloodlineSchema = import_zod44.z.looseObject({
+  bloodline_id: import_zod44.z.number(),
+  name: import_zod44.z.string(),
+  description: import_zod44.z.string(),
+  race_id: import_zod44.z.number(),
+  corporation_id: import_zod44.z.number(),
+  ship_type_id: import_zod44.z.number().nullable(),
+  charisma: import_zod44.z.number(),
+  intelligence: import_zod44.z.number(),
+  memory: import_zod44.z.number(),
+  perception: import_zod44.z.number(),
+  willpower: import_zod44.z.number()
+});
+var FactionSchema = import_zod44.z.looseObject({
+  faction_id: import_zod44.z.number(),
+  name: import_zod44.z.string(),
+  description: import_zod44.z.string(),
+  size_factor: import_zod44.z.number(),
+  station_count: import_zod44.z.number(),
+  station_system_count: import_zod44.z.number(),
+  is_unique: import_zod44.z.boolean(),
+  solar_system_id: import_zod44.z.number().optional(),
+  corporation_id: import_zod44.z.number().optional(),
+  militia_corporation_id: import_zod44.z.number().optional()
+});
+var RaceSchema = import_zod44.z.looseObject({
+  race_id: import_zod44.z.number(),
+  name: import_zod44.z.string(),
+  description: import_zod44.z.string(),
+  alliance_id: import_zod44.z.number()
+});
+var StationInfoSchema = import_zod44.z.looseObject({
+  station_id: import_zod44.z.number(),
+  name: import_zod44.z.string(),
+  owner: import_zod44.z.number().optional(),
+  system_id: import_zod44.z.number(),
+  type_id: import_zod44.z.number(),
+  race_id: import_zod44.z.number().optional(),
+  reprocessing_efficiency: import_zod44.z.number(),
+  reprocessing_stations_take: import_zod44.z.number(),
+  max_dockable_ship_volume: import_zod44.z.number(),
+  office_rental_cost: import_zod44.z.number(),
+  services: import_zod44.z.array(import_zod44.z.string()),
   position: PositionSchema
 });
-var TypeInfoSchema = import_zod42.z.looseObject({
-  type_id: import_zod42.z.number(),
-  name: import_zod42.z.string(),
-  description: import_zod42.z.string(),
-  published: import_zod42.z.boolean(),
-  group_id: import_zod42.z.number(),
-  market_group_id: import_zod42.z.number().optional(),
-  radius: import_zod42.z.number().optional(),
-  volume: import_zod42.z.number().optional(),
-  packaged_volume: import_zod42.z.number().optional(),
-  capacity: import_zod42.z.number().optional(),
-  portion_size: import_zod42.z.number().optional(),
-  mass: import_zod42.z.number().optional(),
-  icon_id: import_zod42.z.number().optional(),
-  graphic_id: import_zod42.z.number().optional(),
-  dogma_attributes: import_zod42.z.array(
-    import_zod42.z.looseObject({
-      attribute_id: import_zod42.z.number(),
-      value: import_zod42.z.number()
+var TypeInfoSchema = import_zod44.z.looseObject({
+  type_id: import_zod44.z.number(),
+  name: import_zod44.z.string(),
+  description: import_zod44.z.string(),
+  published: import_zod44.z.boolean(),
+  group_id: import_zod44.z.number(),
+  market_group_id: import_zod44.z.number().optional(),
+  radius: import_zod44.z.number().optional(),
+  volume: import_zod44.z.number().optional(),
+  packaged_volume: import_zod44.z.number().optional(),
+  capacity: import_zod44.z.number().optional(),
+  portion_size: import_zod44.z.number().optional(),
+  mass: import_zod44.z.number().optional(),
+  icon_id: import_zod44.z.number().optional(),
+  graphic_id: import_zod44.z.number().optional(),
+  dogma_attributes: import_zod44.z.array(
+    import_zod44.z.looseObject({
+      attribute_id: import_zod44.z.number(),
+      value: import_zod44.z.number()
     })
   ).optional(),
-  dogma_effects: import_zod42.z.array(
-    import_zod42.z.looseObject({
-      effect_id: import_zod42.z.number(),
-      is_default: import_zod42.z.boolean()
+  dogma_effects: import_zod44.z.array(
+    import_zod44.z.looseObject({
+      effect_id: import_zod44.z.number(),
+      is_default: import_zod44.z.boolean()
     })
   ).optional()
 });
-var AsteroidBeltInfoSchema = import_zod42.z.looseObject({
-  name: import_zod42.z.string(),
+var AsteroidBeltInfoSchema = import_zod44.z.looseObject({
+  name: import_zod44.z.string(),
   position: PositionSchema,
-  system_id: import_zod42.z.number()
-});
-var GraphicInfoSchema = import_zod42.z.looseObject({
-  graphic_id: import_zod42.z.number(),
-  collision_file: import_zod42.z.string().optional(),
-  graphic_file: import_zod42.z.string().optional(),
-  icon_folder: import_zod42.z.string().optional(),
-  sof_dna: import_zod42.z.string().optional(),
-  sof_fation_name: import_zod42.z.string().optional(),
-  sof_hull_name: import_zod42.z.string().optional(),
-  sof_race_name: import_zod42.z.string().optional()
-});
-var ItemCategorySchema = import_zod42.z.looseObject({
-  category_id: import_zod42.z.number(),
-  name: import_zod42.z.string(),
-  groups: import_zod42.z.array(import_zod42.z.number()),
-  published: import_zod42.z.boolean()
-});
-var ItemGroupSchema = import_zod42.z.looseObject({
-  group_id: import_zod42.z.number(),
-  name: import_zod42.z.string(),
-  category_id: import_zod42.z.number(),
-  types: import_zod42.z.array(import_zod42.z.number()),
-  published: import_zod42.z.boolean()
-});
-var MoonInfoSchema = import_zod42.z.looseObject({
-  moon_id: import_zod42.z.number(),
-  name: import_zod42.z.string(),
-  system_id: import_zod42.z.number(),
+  system_id: import_zod44.z.number()
+});
+var GraphicInfoSchema = import_zod44.z.looseObject({
+  graphic_id: import_zod44.z.number(),
+  collision_file: import_zod44.z.string().optional(),
+  graphic_file: import_zod44.z.string().optional(),
+  icon_folder: import_zod44.z.string().optional(),
+  sof_dna: import_zod44.z.string().optional(),
+  sof_fation_name: import_zod44.z.string().optional(),
+  sof_hull_name: import_zod44.z.string().optional(),
+  sof_race_name: import_zod44.z.string().optional()
+});
+var ItemCategorySchema = import_zod44.z.looseObject({
+  category_id: import_zod44.z.number(),
+  name: import_zod44.z.string(),
+  groups: import_zod44.z.array(import_zod44.z.number()),
+  published: import_zod44.z.boolean()
+});
+var ItemGroupSchema = import_zod44.z.looseObject({
+  group_id: import_zod44.z.number(),
+  name: import_zod44.z.string(),
+  category_id: import_zod44.z.number(),
+  types: import_zod44.z.array(import_zod44.z.number()),
+  published: import_zod44.z.boolean()
+});
+var MoonInfoSchema = import_zod44.z.looseObject({
+  moon_id: import_zod44.z.number(),
+  name: import_zod44.z.string(),
+  system_id: import_zod44.z.number(),
   position: PositionSchema
 });
-var PlanetInfoSchema = import_zod42.z.looseObject({
-  planet_id: import_zod42.z.number(),
-  name: import_zod42.z.string(),
-  system_id: import_zod42.z.number(),
-  type_id: import_zod42.z.number(),
+var PlanetInfoSchema = import_zod44.z.looseObject({
+  planet_id: import_zod44.z.number(),
+  name: import_zod44.z.string(),
+  system_id: import_zod44.z.number(),
+  type_id: import_zod44.z.number(),
   position: PositionSchema
 });
-var StarInfoSchema = import_zod42.z.looseObject({
-  star_id: import_zod42.z.number().optional(),
-  solar_system_id: import_zod42.z.number(),
-  name: import_zod42.z.string(),
-  type_id: import_zod42.z.number(),
-  age: import_zod42.z.number(),
-  luminosity: import_zod42.z.number(),
-  radius: import_zod42.z.number(),
-  spectral_class: import_zod42.z.string(),
-  temperature: import_zod42.z.number()
-});
-var StargateInfoSchema = import_zod42.z.looseObject({
-  stargate_id: import_zod42.z.number(),
-  name: import_zod42.z.string(),
-  system_id: import_zod42.z.number(),
-  type_id: import_zod42.z.number(),
+var StarInfoSchema = import_zod44.z.looseObject({
+  star_id: import_zod44.z.number().optional(),
+  solar_system_id: import_zod44.z.number(),
+  name: import_zod44.z.string(),
+  type_id: import_zod44.z.number(),
+  age: import_zod44.z.number(),
+  luminosity: import_zod44.z.number(),
+  radius: import_zod44.z.number(),
+  spectral_class: import_zod44.z.string(),
+  temperature: import_zod44.z.number()
+});
+var StargateInfoSchema = import_zod44.z.looseObject({
+  stargate_id: import_zod44.z.number(),
+  name: import_zod44.z.string(),
+  system_id: import_zod44.z.number(),
+  type_id: import_zod44.z.number(),
   position: PositionSchema,
-  destination: import_zod42.z.looseObject({
-    system_id: import_zod42.z.number(),
-    stargate_id: import_zod42.z.number()
+  destination: import_zod44.z.looseObject({
+    system_id: import_zod44.z.number(),
+    stargate_id: import_zod44.z.number()
   })
 });
-var StructureInfoSchema = import_zod42.z.looseObject({
-  structure_id: import_zod42.z.number().optional(),
-  name: import_zod42.z.string(),
-  owner_id: import_zod42.z.number(),
-  solar_system_id: import_zod42.z.number(),
-  type_id: import_zod42.z.number().optional(),
+var StructureInfoSchema = import_zod44.z.looseObject({
+  structure_id: import_zod44.z.number().optional(),
+  name: import_zod44.z.string(),
+  owner_id: import_zod44.z.number(),
+  solar_system_id: import_zod44.z.number(),
+  type_id: import_zod44.z.number().optional(),
   position: PositionSchema.optional()
 });
-var SystemJumpSchema = import_zod42.z.looseObject({
-  system_id: import_zod42.z.number(),
-  ship_jumps: import_zod42.z.number()
-});
-var SystemKillSchema = import_zod42.z.looseObject({
-  system_id: import_zod42.z.number(),
-  npc_kills: import_zod42.z.number(),
-  pod_kills: import_zod42.z.number(),
-  ship_kills: import_zod42.z.number()
-});
-var IdNameSchema = import_zod42.z.looseObject({
-  id: import_zod42.z.number(),
-  name: import_zod42.z.string()
-});
-var BulkIdResultSchema = import_zod42.z.looseObject({
-  agents: import_zod42.z.array(IdNameSchema).optional(),
-  alliances: import_zod42.z.array(IdNameSchema).optional(),
-  characters: import_zod42.z.array(IdNameSchema).optional(),
-  constellations: import_zod42.z.array(IdNameSchema).optional(),
-  corporations: import_zod42.z.array(IdNameSchema).optional(),
-  factions: import_zod42.z.array(IdNameSchema).optional(),
-  inventory_types: import_zod42.z.array(IdNameSchema).optional(),
-  regions: import_zod42.z.array(IdNameSchema).optional(),
-  systems: import_zod42.z.array(IdNameSchema).optional(),
-  stations: import_zod42.z.array(IdNameSchema).optional()
-});
-var NameAndCategorySchema = import_zod42.z.looseObject({
-  id: import_zod42.z.number(),
-  name: import_zod42.z.string(),
-  category: import_zod42.z.enum([
+var SystemJumpSchema = import_zod44.z.looseObject({
+  system_id: import_zod44.z.number(),
+  ship_jumps: import_zod44.z.number()
+});
+var SystemKillSchema = import_zod44.z.looseObject({
+  system_id: import_zod44.z.number(),
+  npc_kills: import_zod44.z.number(),
+  pod_kills: import_zod44.z.number(),
+  ship_kills: import_zod44.z.number()
+});
+var IdNameSchema = import_zod44.z.looseObject({
+  id: import_zod44.z.number(),
+  name: import_zod44.z.string()
+});
+var BulkIdResultSchema = import_zod44.z.looseObject({
+  agents: import_zod44.z.array(IdNameSchema).optional(),
+  alliances: import_zod44.z.array(IdNameSchema).optional(),
+  characters: import_zod44.z.array(IdNameSchema).optional(),
+  constellations: import_zod44.z.array(IdNameSchema).optional(),
+  corporations: import_zod44.z.array(IdNameSchema).optional(),
+  factions: import_zod44.z.array(IdNameSchema).optional(),
+  inventory_types: import_zod44.z.array(IdNameSchema).optional(),
+  regions: import_zod44.z.array(IdNameSchema).optional(),
+  systems: import_zod44.z.array(IdNameSchema).optional(),
+  stations: import_zod44.z.array(IdNameSchema).optional()
+});
+var NameAndCategorySchema = import_zod44.z.looseObject({
+  id: import_zod44.z.number(),
+  name: import_zod44.z.string(),
+  category: import_zod44.z.enum([
     "alliance",
     "character",
     "constellation",
@@ -6376,22 +6490,22 @@ var NameAndCategorySchema = import_zod42.z.looseObject({
     "faction"
   ])
 });
-var SchematicInfoSchema = import_zod42.z.looseObject({
-  schematic_name: import_zod42.z.string(),
-  cycle_time: import_zod42.z.number()
+var SchematicInfoSchema = import_zod44.z.looseObject({
+  schematic_name: import_zod44.z.string(),
+  cycle_time: import_zod44.z.number()
 });
-var SearchResultSchema = import_zod42.z.looseObject({
-  agent: import_zod42.z.array(import_zod42.z.number()).optional(),
-  alliance: import_zod42.z.array(import_zod42.z.number()).optional(),
-  character: import_zod42.z.array(import_zod42.z.number()).optional(),
-  constellation: import_zod42.z.array(import_zod42.z.number()).optional(),
-  corporation: import_zod42.z.array(import_zod42.z.number()).optional(),
-  faction: import_zod42.z.array(import_zod42.z.number()).optional(),
-  inventory_type: import_zod42.z.array(import_zod42.z.number()).optional(),
-  region: import_zod42.z.array(import_zod42.z.number()).optional(),
-  solar_system: import_zod42.z.array(import_zod42.z.number()).optional(),
-  station: import_zod42.z.array(import_zod42.z.number()).optional(),
-  structure: import_zod42.z.array(import_zod42.z.number()).optional()
+var SearchResultSchema = import_zod44.z.looseObject({
+  agent: import_zod44.z.array(import_zod44.z.number()).optional(),
+  alliance: import_zod44.z.array(import_zod44.z.number()).optional(),
+  character: import_zod44.z.array(import_zod44.z.number()).optional(),
+  constellation: import_zod44.z.array(import_zod44.z.number()).optional(),
+  corporation: import_zod44.z.array(import_zod44.z.number()).optional(),
+  faction: import_zod44.z.array(import_zod44.z.number()).optional(),
+  inventory_type: import_zod44.z.array(import_zod44.z.number()).optional(),
+  region: import_zod44.z.array(import_zod44.z.number()).optional(),
+  solar_system: import_zod44.z.array(import_zod44.z.number()).optional(),
+  station: import_zod44.z.array(import_zod44.z.number()).optional(),
+  structure: import_zod44.z.array(import_zod44.z.number()).optional()
 });
 
 // src/core/endpoints/piEndpoints.ts
@@ -6401,7 +6515,7 @@ var piEndpoints = {
     method: "GET",
     requiresAuth: true,
     pathParams: ["characterId"],
-    responseSchema: import_zod43.z.array(PlanetaryColonySchema)
+    responseSchema: import_zod45.z.array(PlanetaryColonySchema)
   },
   getColonyLayout: {
     path: "characters/{characterId}/planets/{planetId}",
@@ -6415,7 +6529,7 @@ var piEndpoints = {
     method: "GET",
     requiresAuth: true,
     pathParams: ["corporationId"],
-    responseSchema: import_zod43.z.array(CustomsOfficeSchema)
+    responseSchema: import_zod45.z.array(CustomsOfficeSchema)
   },
   getSchematicInformation: {
     path: "universe/schematics/{schematicId}",
@@ -6483,7 +6597,7 @@ var PiClient = class extends BaseEsiClient {
 };
 
 // src/core/endpoints/routeEndpoints.ts
-var import_zod44 = require("zod");
+var import_zod46 = require("zod");
 var routeEndpoints = {
   getRoute: {
     path: "route/{origin}/{destination}",
@@ -6491,7 +6605,7 @@ var routeEndpoints = {
     requiresAuth: false,
     pathParams: ["origin", "destination"],
     hasBody: true,
-    responseSchema: import_zod44.z.looseObject({ route: import_zod44.z.array(import_zod44.z.number()) })
+    responseSchema: import_zod46.z.looseObject({ route: import_zod46.z.array(import_zod46.z.number()) })
   }
 };
 
@@ -6550,37 +6664,37 @@ var SearchClient = class extends BaseEsiClient {
 };
 
 // src/core/endpoints/skillEndpoints.ts
-var import_zod46 = require("zod");
+var import_zod48 = require("zod");
 
 // src/schemas/skills.ts
-var import_zod45 = require("zod");
-var CharacterSkillSchema = import_zod45.z.looseObject({
-  skill_id: import_zod45.z.number(),
-  skillpoints_in_skill: import_zod45.z.number(),
-  trained_skill_level: import_zod45.z.number(),
-  active_skill_level: import_zod45.z.number()
-});
-var CharacterSkillsResponseSchema = import_zod45.z.looseObject({
-  skills: import_zod45.z.array(
-    import_zod45.z.looseObject({
-      skill_id: import_zod45.z.number(),
-      skillpoints_in_skill: import_zod45.z.number(),
-      trained_skill_level: import_zod45.z.number(),
-      active_skill_level: import_zod45.z.number()
+var import_zod47 = require("zod");
+var CharacterSkillSchema = import_zod47.z.looseObject({
+  skill_id: import_zod47.z.number(),
+  skillpoints_in_skill: import_zod47.z.number(),
+  trained_skill_level: import_zod47.z.number(),
+  active_skill_level: import_zod47.z.number()
+});
+var CharacterSkillsResponseSchema = import_zod47.z.looseObject({
+  skills: import_zod47.z.array(
+    import_zod47.z.looseObject({
+      skill_id: import_zod47.z.number(),
+      skillpoints_in_skill: import_zod47.z.number(),
+      trained_skill_level: import_zod47.z.number(),
+      active_skill_level: import_zod47.z.number()
     })
   ),
-  total_sp: import_zod45.z.number(),
-  unallocated_sp: import_zod45.z.number().optional()
+  total_sp: import_zod47.z.number(),
+  unallocated_sp: import_zod47.z.number().optional()
 });
-var SkillQueueSchema = import_zod45.z.looseObject({
-  skill_id: import_zod45.z.number(),
-  finished_level: import_zod45.z.number(),
-  queue_position: import_zod45.z.number(),
-  level_end_sp: import_zod45.z.number().optional(),
-  level_start_sp: import_zod45.z.number().optional(),
-  training_start_sp: import_zod45.z.number().optional(),
-  start_date: import_zod45.z.string().optional(),
-  finish_date: import_zod45.z.string().optional()
+var SkillQueueSchema = import_zod47.z.looseObject({
+  skill_id: import_zod47.z.number(),
+  finished_level: import_zod47.z.number(),
+  queue_position: import_zod47.z.number(),
+  level_end_sp: import_zod47.z.number().optional(),
+  level_start_sp: import_zod47.z.number().optional(),
+  training_start_sp: import_zod47.z.number().optional(),
+  start_date: import_zod47.z.string().optional(),
+  finish_date: import_zod47.z.string().optional()
 });
 
 // src/core/endpoints/skillEndpoints.ts
@@ -6597,7 +6711,7 @@ var skillEndpoints = {
     method: "GET",
     requiresAuth: true,
     pathParams: ["characterId"],
-    responseSchema: import_zod46.z.array(SkillQueueSchema)
+    responseSchema: import_zod48.z.array(SkillQueueSchema)
   },
   getCharacterSkills: {
     path: "characters/{characterId}/skills",
@@ -6652,77 +6766,77 @@ var CharacterSkillsClient = class extends BaseEsiClient {
 };
 
 // src/core/endpoints/sovereigntyEndpoints.ts
-var import_zod48 = require("zod");
+var import_zod50 = require("zod");
 
 // src/schemas/sovereignty.ts
-var import_zod47 = require("zod");
-var SovereigntyCampaignSchema = import_zod47.z.looseObject({
-  campaign_id: import_zod47.z.number(),
-  structure_id: import_zod47.z.number(),
-  solar_system_id: import_zod47.z.number(),
-  constellation_id: import_zod47.z.number(),
-  event_type: import_zod47.z.enum([
+var import_zod49 = require("zod");
+var SovereigntyCampaignSchema = import_zod49.z.looseObject({
+  campaign_id: import_zod49.z.number(),
+  structure_id: import_zod49.z.number(),
+  solar_system_id: import_zod49.z.number(),
+  constellation_id: import_zod49.z.number(),
+  event_type: import_zod49.z.enum([
     "tcu_defense",
     "ihub_defense",
     "station_defense",
     "station_freeport"
   ]),
-  start_time: import_zod47.z.string(),
-  defender_id: import_zod47.z.number().optional(),
-  defender_score: import_zod47.z.number().optional(),
-  attackers_score: import_zod47.z.number().optional(),
-  participants: import_zod47.z.array(
-    import_zod47.z.looseObject({
-      alliance_id: import_zod47.z.number(),
-      score: import_zod47.z.number()
+  start_time: import_zod49.z.string(),
+  defender_id: import_zod49.z.number().optional(),
+  defender_score: import_zod49.z.number().optional(),
+  attackers_score: import_zod49.z.number().optional(),
+  participants: import_zod49.z.array(
+    import_zod49.z.looseObject({
+      alliance_id: import_zod49.z.number(),
+      score: import_zod49.z.number()
     })
   ).optional()
 });
-var SovereigntySystemStructureSchema = import_zod47.z.looseObject({
-  alliance_id: import_zod47.z.number().optional(),
-  solar_system_id: import_zod47.z.number().optional(),
-  structure_id: import_zod47.z.number(),
-  structure_type_id: import_zod47.z.number(),
-  vulnerability_occupancy_level: import_zod47.z.number().optional(),
-  vulnerable_start_time: import_zod47.z.string().optional(),
-  vulnerable_end_time: import_zod47.z.string().optional()
-});
-var SovereigntyVulnerabilityWindowSchema = import_zod47.z.looseObject({
-  start: import_zod47.z.string(),
-  end: import_zod47.z.string()
-});
-var SovereigntyHubSchema = import_zod47.z.looseObject({
-  id: import_zod47.z.number(),
+var SovereigntySystemStructureSchema = import_zod49.z.looseObject({
+  alliance_id: import_zod49.z.number().optional(),
+  solar_system_id: import_zod49.z.number().optional(),
+  structure_id: import_zod49.z.number(),
+  structure_type_id: import_zod49.z.number(),
+  vulnerability_occupancy_level: import_zod49.z.number().optional(),
+  vulnerable_start_time: import_zod49.z.string().optional(),
+  vulnerable_end_time: import_zod49.z.string().optional()
+});
+var SovereigntyVulnerabilityWindowSchema = import_zod49.z.looseObject({
+  start: import_zod49.z.string(),
+  end: import_zod49.z.string()
+});
+var SovereigntyHubSchema = import_zod49.z.looseObject({
+  id: import_zod49.z.number(),
   vulnerability_window: SovereigntyVulnerabilityWindowSchema.optional()
 });
-var SovereigntyDevelopmentSchema = import_zod47.z.looseObject({
-  activity_defense_multiplier: import_zod47.z.number().optional(),
-  military_level: import_zod47.z.number().optional(),
-  industrial_level: import_zod47.z.number().optional(),
-  strategic_level: import_zod47.z.number().optional()
+var SovereigntyDevelopmentSchema = import_zod49.z.looseObject({
+  activity_defense_multiplier: import_zod49.z.number().optional(),
+  military_level: import_zod49.z.number().optional(),
+  industrial_level: import_zod49.z.number().optional(),
+  strategic_level: import_zod49.z.number().optional()
 });
-var SovereigntyAllianceClaimSchema = import_zod47.z.looseObject({
-  alliance_id: import_zod47.z.number(),
-  corporation_id: import_zod47.z.number().optional(),
-  claimed_since: import_zod47.z.string().optional(),
+var SovereigntyAllianceClaimSchema = import_zod49.z.looseObject({
+  alliance_id: import_zod49.z.number(),
+  corporation_id: import_zod49.z.number().optional(),
+  claimed_since: import_zod49.z.string().optional(),
   sovereignty_hub: SovereigntyHubSchema.optional(),
-  is_capital_system: import_zod47.z.boolean().optional(),
+  is_capital_system: import_zod49.z.boolean().optional(),
   development: SovereigntyDevelopmentSchema.optional()
 });
-var SovereigntyFactionClaimSchema = import_zod47.z.looseObject({
-  faction_id: import_zod47.z.number()
+var SovereigntyFactionClaimSchema = import_zod49.z.looseObject({
+  faction_id: import_zod49.z.number()
 });
-var SovereigntyClaimSchema = import_zod47.z.looseObject({
+var SovereigntyClaimSchema = import_zod49.z.looseObject({
   alliance: SovereigntyAllianceClaimSchema.optional(),
   faction: SovereigntyFactionClaimSchema.optional(),
-  unclaimed: import_zod47.z.boolean().optional()
+  unclaimed: import_zod49.z.boolean().optional()
 });
-var SovereigntySystemEntrySchema = import_zod47.z.looseObject({
-  solar_system_id: import_zod47.z.number(),
+var SovereigntySystemEntrySchema = import_zod49.z.looseObject({
+  solar_system_id: import_zod49.z.number(),
   claim: SovereigntyClaimSchema
 });
-var SovereigntySystemSchema = import_zod47.z.looseObject({
-  solar_systems: import_zod47.z.array(SovereigntySystemEntrySchema)
+var SovereigntySystemSchema = import_zod49.z.looseObject({
+  solar_systems: import_zod49.z.array(SovereigntySystemEntrySchema)
 });
 
 // src/core/endpoints/sovereigntyEndpoints.ts
@@ -6731,7 +6845,7 @@ var sovereigntyEndpoints = {
     path: "sovereignty/campaigns",
     method: "GET",
     requiresAuth: false,
-    responseSchema: import_zod48.z.array(SovereigntyCampaignSchema)
+    responseSchema: import_zod50.z.array(SovereigntyCampaignSchema)
   },
   getSovereigntySystems: {
     path: "sovereignty/systems",
@@ -6765,12 +6879,12 @@ var SovereigntyClient = class extends BaseEsiClient {
 };
 
 // src/schemas/status.ts
-var import_zod49 = require("zod");
-var ServerStatusSchema = import_zod49.z.looseObject({
-  players: import_zod49.z.number(),
-  server_version: import_zod49.z.string(),
-  start_time: import_zod49.z.string(),
-  vip: import_zod49.z.boolean().optional()
+var import_zod51 = require("zod");
+var ServerStatusSchema = import_zod51.z.looseObject({
+  players: import_zod51.z.number(),
+  server_version: import_zod51.z.string(),
+  start_time: import_zod51.z.string(),
+  vip: import_zod51.z.boolean().optional()
 });
 
 // src/core/endpoints/statusEndpoints.ts
@@ -6895,13 +7009,13 @@ var UiClient = class extends BaseEsiClient {
 };
 
 // src/core/endpoints/universeEndpoints.ts
-var import_zod50 = require("zod");
+var import_zod52 = require("zod");
 var universeEndpoints = {
   getAncestries: {
     path: "universe/ancestries",
     method: "GET",
     requiresAuth: false,
-    responseSchema: import_zod50.z.array(AncestrySchema)
+    responseSchema: import_zod52.z.array(AncestrySchema)
   },
   getAsteroidBeltInfo: {
     path: "universe/asteroid_belts/{asteroidBeltId}",
@@ -6914,13 +7028,13 @@ var universeEndpoints = {
     path: "universe/bloodlines",
     method: "GET",
     requiresAuth: false,
-    responseSchema: import_zod50.z.array(BloodlineSchema)
+    responseSchema: import_zod52.z.array(BloodlineSchema)
   },
   getCategories: {
     path: "universe/categories",
     method: "GET",
     requiresAuth: false,
-    responseSchema: import_zod50.z.array(import_zod50.z.number())
+    responseSchema: import_zod52.z.array(import_zod52.z.number())
   },
   getCategoryById: {
     path: "universe/categories/{categoryId}",
@@ -6933,7 +7047,7 @@ var universeEndpoints = {
     path: "universe/constellations",
     method: "GET",
     requiresAuth: false,
-    responseSchema: import_zod50.z.array(import_zod50.z.number())
+    responseSchema: import_zod52.z.array(import_zod52.z.number())
   },
   getConstellationById: {
     path: "universe/constellations/{constellationId}",
@@ -6946,13 +7060,13 @@ var universeEndpoints = {
     path: "universe/factions",
     method: "GET",
     requiresAuth: false,
-    responseSchema: import_zod50.z.array(FactionSchema)
+    responseSchema: import_zod52.z.array(FactionSchema)
   },
   getGraphics: {
     path: "universe/graphics",
     method: "GET",
     requiresAuth: false,
-    responseSchema: import_zod50.z.array(import_zod50.z.number())
+    responseSchema: import_zod52.z.array(import_zod52.z.number())
   },
   getGraphicById: {
     path: "universe/graphics/{graphicId}",
@@ -6965,7 +7079,7 @@ var universeEndpoints = {
     path: "universe/groups",
     method: "GET",
     requiresAuth: false,
-    responseSchema: import_zod50.z.array(import_zod50.z.number())
+    responseSchema: import_zod52.z.array(import_zod52.z.number())
   },
   getItemGroupById: {
     path: "universe/groups/{groupId}",
@@ -6980,7 +7094,7 @@ var universeEndpoints = {
     requiresAuth: false,
     bodyBuilder: (names) => names,
     responseSchema: BulkIdResultSchema,
-    requestSchema: import_zod50.z.array(import_zod50.z.string().min(1))
+    requestSchema: import_zod52.z.array(import_zod52.z.string().min(1))
   },
   getMoonById: {
     path: "universe/moons/{moonId}",
@@ -6994,8 +7108,8 @@ var universeEndpoints = {
     method: "POST",
     requiresAuth: false,
     bodyBuilder: (ids) => ids,
-    responseSchema: import_zod50.z.array(NameAndCategorySchema),
-    requestSchema: import_zod50.z.array(import_zod50.z.number().int())
+    responseSchema: import_zod52.z.array(NameAndCategorySchema),
+    requestSchema: import_zod52.z.array(import_zod52.z.number().int())
   },
   getPlanetById: {
     path: "universe/planets/{planetId}",
@@ -7008,13 +7122,13 @@ var universeEndpoints = {
     path: "universe/races",
     method: "GET",
     requiresAuth: false,
-    responseSchema: import_zod50.z.array(RaceSchema)
+    responseSchema: import_zod52.z.array(RaceSchema)
   },
   getRegions: {
     path: "universe/regions",
     method: "GET",
     requiresAuth: false,
-    responseSchema: import_zod50.z.array(import_zod50.z.number())
+    responseSchema: import_zod52.z.array(import_zod52.z.number())
   },
   getRegionById: {
     path: "universe/regions/{regionId}",
@@ -7055,7 +7169,7 @@ var universeEndpoints = {
     path: "universe/structures",
     method: "GET",
     requiresAuth: false,
-    responseSchema: import_zod50.z.array(import_zod50.z.number())
+    responseSchema: import_zod52.z.array(import_zod52.z.number())
   },
   getStructureById: {
     path: "universe/structures/{structureId}",
@@ -7068,19 +7182,19 @@ var universeEndpoints = {
     path: "universe/system_jumps",
     method: "GET",
     requiresAuth: false,
-    responseSchema: import_zod50.z.array(SystemJumpSchema)
+    responseSchema: import_zod52.z.array(SystemJumpSchema)
   },
   getSystemKills: {
     path: "universe/system_kills",
     method: "GET",
     requiresAuth: false,
-    responseSchema: import_zod50.z.array(SystemKillSchema)
+    responseSchema: import_zod52.z.array(SystemKillSchema)
   },
   getSystems: {
     path: "universe/systems",
     method: "GET",
     requiresAuth: false,
-    responseSchema: import_zod50.z.array(import_zod50.z.number())
+    responseSchema: import_zod52.z.array(import_zod52.z.number())
   },
   getSystemById: {
     path: "universe/systems/{systemId}",
@@ -7093,7 +7207,7 @@ var universeEndpoints = {
     path: "universe/types",
     method: "GET",
     requiresAuth: false,
-    responseSchema: import_zod50.z.array(import_zod50.z.number())
+    responseSchema: import_zod52.z.array(import_zod52.z.number())
   },
   getTypeById: {
     path: "universe/types/{typeId}",
@@ -7382,36 +7496,36 @@ var UniverseClient = class extends BaseEsiClient {
 };
 
 // src/core/endpoints/walletEndpoints.ts
-var import_zod52 = require("zod");
+var import_zod54 = require("zod");
 
 // src/schemas/wallet.ts
-var import_zod51 = require("zod");
-var WalletTransactionSchema = import_zod51.z.looseObject({
-  transaction_id: import_zod51.z.number(),
-  date: import_zod51.z.string(),
-  type_id: import_zod51.z.number(),
-  location_id: import_zod51.z.number(),
-  unit_price: import_zod51.z.number(),
-  quantity: import_zod51.z.number(),
-  client_id: import_zod51.z.number(),
-  is_buy: import_zod51.z.boolean(),
-  is_personal: import_zod51.z.boolean(),
-  journal_ref_id: import_zod51.z.number()
-});
-var WalletJournalSchema = import_zod51.z.looseObject({
-  id: import_zod51.z.number(),
-  date: import_zod51.z.string(),
-  ref_type: import_zod51.z.string(),
-  first_party_id: import_zod51.z.number().optional(),
-  second_party_id: import_zod51.z.number().optional(),
-  amount: import_zod51.z.number().optional(),
-  balance: import_zod51.z.number().optional(),
-  reason: import_zod51.z.string().optional(),
-  description: import_zod51.z.string(),
-  context_id: import_zod51.z.number().optional(),
-  context_id_type: import_zod51.z.string().optional(),
-  tax: import_zod51.z.number().optional(),
-  tax_receiver_id: import_zod51.z.number().optional()
+var import_zod53 = require("zod");
+var WalletTransactionSchema = import_zod53.z.looseObject({
+  transaction_id: import_zod53.z.number(),
+  date: import_zod53.z.string(),
+  type_id: import_zod53.z.number(),
+  location_id: import_zod53.z.number(),
+  unit_price: import_zod53.z.number(),
+  quantity: import_zod53.z.number(),
+  client_id: import_zod53.z.number(),
+  is_buy: import_zod53.z.boolean(),
+  is_personal: import_zod53.z.boolean(),
+  journal_ref_id: import_zod53.z.number()
+});
+var WalletJournalSchema = import_zod53.z.looseObject({
+  id: import_zod53.z.number(),
+  date: import_zod53.z.string(),
+  ref_type: import_zod53.z.string(),
+  first_party_id: import_zod53.z.number().optional(),
+  second_party_id: import_zod53.z.number().optional(),
+  amount: import_zod53.z.number().optional(),
+  balance: import_zod53.z.number().optional(),
+  reason: import_zod53.z.string().optional(),
+  description: import_zod53.z.string(),
+  context_id: import_zod53.z.number().optional(),
+  context_id_type: import_zod53.z.string().optional(),
+  tax: import_zod53.z.number().optional(),
+  tax_receiver_id: import_zod53.z.number().optional()
 });
 
 // src/core/endpoints/walletEndpoints.ts
@@ -7421,42 +7535,42 @@ var walletEndpoints = {
     method: "GET",
     requiresAuth: true,
     pathParams: ["characterId"],
-    responseSchema: import_zod52.z.number()
+    responseSchema: import_zod54.z.number()
   },
   getCharacterWalletJournal: {
     path: "characters/{characterId}/wallet/journal",
     method: "GET",
     requiresAuth: true,
     pathParams: ["characterId"],
-    responseSchema: import_zod52.z.array(WalletJournalSchema)
+    responseSchema: import_zod54.z.array(WalletJournalSchema)
   },
   getCharacterWalletTransactions: {
     path: "characters/{characterId}/wallet/transactions",
     method: "GET",
     requiresAuth: true,
     pathParams: ["characterId"],
-    responseSchema: import_zod52.z.array(WalletTransactionSchema)
+    responseSchema: import_zod54.z.array(WalletTransactionSchema)
   },
   getCorporationWallets: {
     path: "corporations/{corporationId}/wallets",
     method: "GET",
     requiresAuth: true,
     pathParams: ["corporationId"],
-    responseSchema: import_zod52.z.array(CorporationWalletDivisionSchema)
+    responseSchema: import_zod54.z.array(CorporationWalletDivisionSchema)
   },
   getCorporationWalletJournal: {
     path: "corporations/{corporationId}/wallets/{division}/journal",
     method: "GET",
     requiresAuth: true,
     pathParams: ["corporationId", "division"],
-    responseSchema: import_zod52.z.array(WalletJournalSchema)
+    responseSchema: import_zod54.z.array(WalletJournalSchema)
   },
   getCorporationWalletTransactions: {
     path: "corporations/{corporationId}/wallets/{division}/transactions",
     method: "GET",
     requiresAuth: true,
     pathParams: ["corporationId", "division"],
-    responseSchema: import_zod52.z.array(WalletTransactionSchema)
+    responseSchema: import_zod54.z.array(WalletTransactionSchema)
   }
 };
 
@@ -7556,34 +7670,34 @@ var WalletClient = class extends BaseEsiClient {
 };
 
 // src/core/endpoints/warEndpoints.ts
-var import_zod54 = require("zod");
+var import_zod56 = require("zod");
 
 // src/schemas/wars.ts
-var import_zod53 = require("zod");
-var WarSchema = import_zod53.z.looseObject({
-  id: import_zod53.z.number(),
-  declared: import_zod53.z.string(),
-  started: import_zod53.z.string().optional(),
-  finished: import_zod53.z.string().optional(),
-  retracted: import_zod53.z.string().optional(),
-  mutual: import_zod53.z.boolean(),
-  open_for_allies: import_zod53.z.boolean(),
-  aggressor: import_zod53.z.looseObject({
-    corporation_id: import_zod53.z.number().optional(),
-    alliance_id: import_zod53.z.number().optional(),
-    isk_destroyed: import_zod53.z.number(),
-    ships_killed: import_zod53.z.number()
+var import_zod55 = require("zod");
+var WarSchema = import_zod55.z.looseObject({
+  id: import_zod55.z.number(),
+  declared: import_zod55.z.string(),
+  started: import_zod55.z.string().optional(),
+  finished: import_zod55.z.string().optional(),
+  retracted: import_zod55.z.string().optional(),
+  mutual: import_zod55.z.boolean(),
+  open_for_allies: import_zod55.z.boolean(),
+  aggressor: import_zod55.z.looseObject({
+    corporation_id: import_zod55.z.number().optional(),
+    alliance_id: import_zod55.z.number().optional(),
+    isk_destroyed: import_zod55.z.number(),
+    ships_killed: import_zod55.z.number()
   }),
-  defender: import_zod53.z.looseObject({
-    corporation_id: import_zod53.z.number().optional(),
-    alliance_id: import_zod53.z.number().optional(),
-    isk_destroyed: import_zod53.z.number(),
-    ships_killed: import_zod53.z.number()
+  defender: import_zod55.z.looseObject({
+    corporation_id: import_zod55.z.number().optional(),
+    alliance_id: import_zod55.z.number().optional(),
+    isk_destroyed: import_zod55.z.number(),
+    ships_killed: import_zod55.z.number()
   }),
-  allies: import_zod53.z.array(
-    import_zod53.z.looseObject({
-      corporation_id: import_zod53.z.number().optional(),
-      alliance_id: import_zod53.z.number().optional()
+  allies: import_zod55.z.array(
+    import_zod55.z.looseObject({
+      corporation_id: import_zod55.z.number().optional(),
+      alliance_id: import_zod55.z.number().optional()
     })
   ).optional()
 });
@@ -7594,7 +7708,7 @@ var warEndpoints = {
     path: "wars",
     method: "GET",
     requiresAuth: false,
-    responseSchema: import_zod54.z.array(import_zod54.z.number())
+    responseSchema: import_zod56.z.array(import_zod56.z.number())
   },
   getWarById: {
     path: "wars/{warId}",
@@ -7608,7 +7722,7 @@ var warEndpoints = {
     method: "GET",
     requiresAuth: false,
     pathParams: ["warId"],
-    responseSchema: import_zod54.z.array(KillmailSummarySchema)
+    responseSchema: import_zod56.z.array(KillmailSummarySchema)
   }
 };
 
@@ -7652,13 +7766,62 @@ var WarsClient = class extends BaseEsiClient {
 };
 
 // src/core/endpoints/metaEndpoints.ts
-var import_zod55 = require("zod");
+var import_zod58 = require("zod");
+
+// src/schemas/meta.ts
+var import_zod57 = require("zod");
+var MetaChangelogEntrySchema = import_zod57.z.looseObject({
+  method: import_zod57.z.string(),
+  path: import_zod57.z.string(),
+  compatibility_date: import_zod57.z.string(),
+  is_breaking: import_zod57.z.boolean(),
+  description: import_zod57.z.string()
+});
+var MetaChangelogSchema = import_zod57.z.record(
+  import_zod57.z.string(),
+  import_zod57.z.array(MetaChangelogEntrySchema)
+);
+var MetaCompatibilityDatesSchema = import_zod57.z.looseObject({
+  compatibility_dates: import_zod57.z.array(import_zod57.z.string())
+});
+var MetaNameSchema = import_zod57.z.looseObject({
+  name: import_zod57.z.string()
+});
+var MetaStatusSchema = import_zod57.z.looseObject({
+  status: import_zod57.z.string()
+});
+
+// src/core/endpoints/metaEndpoints.ts
 var metaEndpoints = {
   getOpenApiJson: {
     path: "meta/openapi.json",
     method: "GET",
     requiresAuth: false,
-    responseSchema: import_zod55.z.record(import_zod55.z.string(), import_zod55.z.unknown())
+    responseSchema: import_zod58.z.record(import_zod58.z.string(), import_zod58.z.unknown())
+  },
+  getChangelog: {
+    path: "meta/changelog",
+    method: "GET",
+    requiresAuth: false,
+    responseSchema: MetaChangelogSchema
+  },
+  getCompatibilityDates: {
+    path: "meta/compatibility-dates",
+    method: "GET",
+    requiresAuth: false,
+    responseSchema: MetaCompatibilityDatesSchema
+  },
+  getName: {
+    path: "meta/name",
+    method: "GET",
+    requiresAuth: false,
+    responseSchema: MetaNameSchema
+  },
+  getStatus: {
+    path: "meta/status",
+    method: "GET",
+    requiresAuth: false,
+    responseSchema: MetaStatusSchema
   }
 };
 
@@ -7708,105 +7871,137 @@ var MetaClient = class extends BaseEsiClient {
       }
     }
   }
+  /**
+   * Retrieves the ESI changelog data.
+   *
+   * @returns The changelog keyed by compatibility date
+   */
+  getChangelog() {
+    return this.api.getChangelog();
+  }
+  /**
+   * Retrieves the list of ESI compatibility dates.
+   *
+   * @returns An object containing the list of compatibility dates
+   */
+  getCompatibilityDates() {
+    return this.api.getCompatibilityDates();
+  }
+  /**
+   * Retrieves the ESI name.
+   *
+   * @returns An object containing the ESI name
+   */
+  getName() {
+    return this.api.getName();
+  }
+  /**
+   * Retrieves the ESI status.
+   *
+   * @returns An object containing the ESI status
+   */
+  getStatus() {
+    return this.api.getStatus();
+  }
 };
 
 // src/core/endpoints/freelanceJobsEndpoints.ts
-var import_zod57 = require("zod");
+var import_zod60 = require("zod");
 
 // src/schemas/freelance-jobs.ts
-var import_zod56 = require("zod");
-var EsiCursorSchema = import_zod56.z.looseObject({
-  before: import_zod56.z.string().nullable(),
-  after: import_zod56.z.string().nullable()
-});
-var FreelanceJobSummarySchema = import_zod56.z.looseObject({
-  id: import_zod56.z.string(),
-  name: import_zod56.z.string(),
-  state: import_zod56.z.string(),
-  last_modified: import_zod56.z.string(),
-  progress: import_zod56.z.looseObject({
-    current: import_zod56.z.number(),
-    desired: import_zod56.z.number()
+var import_zod59 = require("zod");
+var EsiCursorSchema = import_zod59.z.looseObject({
+  before: import_zod59.z.string().nullable(),
+  after: import_zod59.z.string().nullable()
+});
+var FreelanceJobSummarySchema = import_zod59.z.looseObject({
+  id: import_zod59.z.string(),
+  name: import_zod59.z.string(),
+  state: import_zod59.z.string(),
+  last_modified: import_zod59.z.string(),
+  progress: import_zod59.z.looseObject({
+    current: import_zod59.z.number(),
+    desired: import_zod59.z.number()
   }),
-  reward: import_zod56.z.looseObject({
-    initial: import_zod56.z.number(),
-    remaining: import_zod56.z.number()
+  reward: import_zod59.z.looseObject({
+    initial: import_zod59.z.number(),
+    remaining: import_zod59.z.number()
   }).optional()
 });
-var FreelanceJobsListingSchema = import_zod56.z.looseObject({
+var FreelanceJobsListingSchema = import_zod59.z.looseObject({
   cursor: EsiCursorSchema.optional(),
-  freelance_jobs: import_zod56.z.array(FreelanceJobSummarySchema)
-});
-var FreelanceJobDetailSchema = import_zod56.z.looseObject({
-  id: import_zod56.z.string(),
-  name: import_zod56.z.string(),
-  state: import_zod56.z.string(),
-  last_modified: import_zod56.z.string(),
-  progress: import_zod56.z.looseObject({
-    current: import_zod56.z.number(),
-    desired: import_zod56.z.number()
+  freelance_jobs: import_zod59.z.array(FreelanceJobSummarySchema)
+});
+var FreelanceJobDetailSchema = import_zod59.z.looseObject({
+  id: import_zod59.z.string(),
+  name: import_zod59.z.string(),
+  state: import_zod59.z.string(),
+  last_modified: import_zod59.z.string(),
+  progress: import_zod59.z.looseObject({
+    current: import_zod59.z.number(),
+    desired: import_zod59.z.number()
   }),
-  reward: import_zod56.z.looseObject({
-    initial: import_zod56.z.number(),
-    remaining: import_zod56.z.number()
+  reward: import_zod59.z.looseObject({
+    initial: import_zod59.z.number(),
+    remaining: import_zod59.z.number()
   }).optional(),
-  details: import_zod56.z.looseObject({
-    description: import_zod56.z.string(),
-    career: import_zod56.z.string(),
-    created: import_zod56.z.string(),
-    expires: import_zod56.z.string(),
-    creator: import_zod56.z.looseObject({
-      character: import_zod56.z.looseObject({
-        id: import_zod56.z.number(),
-        name: import_zod56.z.string()
+  details: import_zod59.z.looseObject({
+    description: import_zod59.z.string(),
+    career: import_zod59.z.string(),
+    created: import_zod59.z.string(),
+    expires: import_zod59.z.string(),
+    creator: import_zod59.z.looseObject({
+      character: import_zod59.z.looseObject({
+        id: import_zod59.z.number(),
+        name: import_zod59.z.string()
       }),
-      corporation: import_zod56.z.looseObject({
-        id: import_zod56.z.number(),
-        name: import_zod56.z.string()
+      corporation: import_zod59.z.looseObject({
+        id: import_zod59.z.number(),
+        name: import_zod59.z.string()
       })
     })
   }),
-  configuration: import_zod56.z.looseObject({
-    version: import_zod56.z.number(),
-    parameters: import_zod56.z.record(import_zod56.z.string(), import_zod56.z.unknown()),
-    method: import_zod56.z.string()
+  configuration: import_zod59.z.looseObject({
+    version: import_zod59.z.number(),
+    parameters: import_zod59.z.record(import_zod59.z.string(), import_zod59.z.unknown()),
+    method: import_zod59.z.string()
   }),
-  contribution: import_zod56.z.looseObject({
-    max_committed_participants: import_zod56.z.number(),
-    reward_per_contribution: import_zod56.z.number().optional(),
-    submission_multiplier: import_zod56.z.number().optional()
+  contribution: import_zod59.z.looseObject({
+    max_committed_participants: import_zod59.z.number(),
+    reward_per_contribution: import_zod59.z.number().optional(),
+    submission_multiplier: import_zod59.z.number().optional()
   }),
-  access_and_visibility: import_zod56.z.looseObject({
-    acl_protected: import_zod56.z.boolean(),
-    broadcast_locations: import_zod56.z.array(
-      import_zod56.z.looseObject({
-        id: import_zod56.z.number(),
-        name: import_zod56.z.string()
+  access_and_visibility: import_zod59.z.looseObject({
+    acl_protected: import_zod59.z.boolean(),
+    broadcast_locations: import_zod59.z.array(
+      import_zod59.z.looseObject({
+        id: import_zod59.z.number(),
+        name: import_zod59.z.string()
       })
     )
   })
 });
-var CharacterFreelanceJobsListingSchema = import_zod56.z.looseObject({
+var CharacterFreelanceJobsListingSchema = import_zod59.z.looseObject({
   cursor: EsiCursorSchema.optional(),
-  freelance_jobs: import_zod56.z.array(FreelanceJobSummarySchema)
+  freelance_jobs: import_zod59.z.array(FreelanceJobSummarySchema)
 });
-var FreelanceJobParticipationSchema = import_zod56.z.looseObject({
-  job_id: import_zod56.z.string(),
-  character_id: import_zod56.z.number(),
-  status: import_zod56.z.string(),
-  contributions: import_zod56.z.number(),
-  last_contribution: import_zod56.z.string().optional()
+var FreelanceJobParticipationSchema = import_zod59.z.looseObject({
+  job_id: import_zod59.z.string(),
+  character_id: import_zod59.z.number(),
+  status: import_zod59.z.string(),
+  contributions: import_zod59.z.number(),
+  last_contribution: import_zod59.z.string().optional()
 });
-var CorporationFreelanceJobsListingSchema = import_zod56.z.looseObject({
+var CorporationFreelanceJobsListingSchema = import_zod59.z.looseObject({
   cursor: EsiCursorSchema.optional(),
-  freelance_jobs: import_zod56.z.array(FreelanceJobSummarySchema)
+  freelance_jobs: import_zod59.z.array(FreelanceJobSummarySchema)
 });
-var FreelanceJobParticipantSchema = import_zod56.z.looseObject({
-  character_id: import_zod56.z.number(),
-  corporation_id: import_zod56.z.number(),
-  status: import_zod56.z.string(),
-  contributions: import_zod56.z.number(),
-  last_contribution: import_zod56.z.string().optional()
+var FreelanceJobParticipantSchema = import_zod59.z.looseObject({
+  character_id: import_zod59.z.number(),
+  corporation_id: import_zod59.z.number(),
+  status: import_zod59.z.string(),
+  contributions: import_zod59.z.number(),
+  last_contribution: import_zod59.z.string().optional()
 });
 
 // src/core/endpoints/freelanceJobsEndpoints.ts
@@ -7853,7 +8048,7 @@ var freelanceJobsEndpoints = {
     method: "GET",
     requiresAuth: true,
     pathParams: ["corporationId", "jobId"],
-    responseSchema: import_zod57.z.array(FreelanceJobParticipantSchema)
+    responseSchema: import_zod60.z.array(FreelanceJobParticipantSchema)
   }
 };
 
@@ -7947,56 +8142,58 @@ var FreelanceJobsClient = class extends BaseEsiClient {
 };
 
 // src/core/endpoints/skyhookEndpoints.ts
-var import_zod59 = require("zod");
+var import_zod62 = require("zod");
 
 // src/schemas/skyhooks.ts
-var import_zod58 = require("zod");
-var SovereigntyHubSchema2 = import_zod58.z.looseObject({
-  structure_id: import_zod58.z.number(),
-  system_id: import_zod58.z.number(),
-  corporation_id: import_zod58.z.number(),
-  alliance_id: import_zod58.z.number().optional(),
-  online: import_zod58.z.boolean(),
-  remaining_reagents: import_zod58.z.number().optional(),
-  installed_upgrades: import_zod58.z.array(import_zod58.z.number()).optional()
-});
-var OrbitalSkyhookSchema = import_zod58.z.looseObject({
-  structure_id: import_zod58.z.number(),
-  system_id: import_zod58.z.number(),
-  corporation_id: import_zod58.z.number(),
-  alliance_id: import_zod58.z.number().optional(),
-  online: import_zod58.z.boolean(),
-  reagent_silo_capacity: import_zod58.z.number().optional(),
-  reagent_silo_level: import_zod58.z.number().optional()
-});
-var RaidableSkyhookSchema = import_zod58.z.looseObject({
-  structure_id: import_zod58.z.number(),
-  system_id: import_zod58.z.number(),
-  corporation_id: import_zod58.z.number(),
-  alliance_id: import_zod58.z.number().optional(),
-  raidable_at: import_zod58.z.string().optional(),
-  is_raidable: import_zod58.z.boolean()
+var import_zod61 = require("zod");
+var SovereigntyHubSchema2 = import_zod61.z.looseObject({
+  structure_id: import_zod61.z.number(),
+  system_id: import_zod61.z.number(),
+  corporation_id: import_zod61.z.number(),
+  alliance_id: import_zod61.z.number().optional(),
+  online: import_zod61.z.boolean(),
+  remaining_reagents: import_zod61.z.number().optional(),
+  installed_upgrades: import_zod61.z.array(import_zod61.z.number()).optional()
+});
+var OrbitalSkyhookSchema = import_zod61.z.looseObject({
+  structure_id: import_zod61.z.number(),
+  system_id: import_zod61.z.number(),
+  corporation_id: import_zod61.z.number(),
+  alliance_id: import_zod61.z.number().optional(),
+  online: import_zod61.z.boolean(),
+  reagent_silo_capacity: import_zod61.z.number().optional(),
+  reagent_silo_level: import_zod61.z.number().optional()
+});
+var RaidableSkyhookSchema = import_zod61.z.looseObject({
+  structure_id: import_zod61.z.number(),
+  system_id: import_zod61.z.number(),
+  corporation_id: import_zod61.z.number(),
+  alliance_id: import_zod61.z.number().optional(),
+  raidable_at: import_zod61.z.string().optional(),
+  is_raidable: import_zod61.z.boolean()
 });
 
 // src/core/endpoints/skyhookEndpoints.ts
 var skyhookEndpoints = {
   getSovereigntyHubs: {
-    path: "sovereignty/hubs",
+    path: "corporations/{corporationId}/structures/sovereignty-hubs",
     method: "GET",
-    requiresAuth: false,
-    responseSchema: import_zod59.z.array(SovereigntyHubSchema2)
+    requiresAuth: true,
+    pathParams: ["corporationId"],
+    responseSchema: import_zod62.z.array(SovereigntyHubSchema2)
   },
   getOrbitalSkyhooks: {
-    path: "sovereignty/skyhooks",
+    path: "corporations/{corporationId}/structures/skyhooks",
     method: "GET",
-    requiresAuth: false,
-    responseSchema: import_zod59.z.array(OrbitalSkyhookSchema)
+    requiresAuth: true,
+    pathParams: ["corporationId"],
+    responseSchema: import_zod62.z.array(OrbitalSkyhookSchema)
   },
   getRaidableSkyhooks: {
-    path: "sovereignty/skyhooks/raidable",
+    path: "skyhooks/raidable",
     method: "GET",
     requiresAuth: false,
-    responseSchema: import_zod59.z.array(RaidableSkyhookSchema)
+    responseSchema: import_zod62.z.array(RaidableSkyhookSchema)
   }
 };
 
@@ -8008,18 +8205,22 @@ var SkyhooksClient = class extends BaseEsiClient {
   /**
    * Retrieves all sovereignty hubs exposed as Upwell structures, including online status and installed upgrades.
    *
+   * @param corporationId - The ID of the corporation to query sovereignty hubs for
    * @returns A list of sovereignty hubs
+   * @requires Authentication
    */
-  getSovereigntyHubs() {
-    return this.api.getSovereigntyHubs();
+  getSovereigntyHubs(corporationId) {
+    return this.api.getSovereigntyHubs(corporationId);
   }
   /**
    * Retrieves all orbital skyhooks with their silo capacity and levels.
    *
+   * @param corporationId - The ID of the corporation to query skyhooks for
    * @returns A list of orbital skyhooks
+   * @requires Authentication
    */
-  getOrbitalSkyhooks() {
-    return this.api.getOrbitalSkyhooks();
+  getOrbitalSkyhooks(corporationId) {
+    return this.api.getOrbitalSkyhooks(corporationId);
   }
   /**
    * Retrieves the rolling list of skyhooks that are currently or becoming raidable across New Eden.
@@ -8032,42 +8233,44 @@ var SkyhooksClient = class extends BaseEsiClient {
 };
 
 // src/core/endpoints/mercenaryEndpoints.ts
-var import_zod61 = require("zod");
+var import_zod64 = require("zod");
 
 // src/schemas/mercenary.ts
-var import_zod60 = require("zod");
-var MercenaryDenSchema = import_zod60.z.looseObject({
-  den_id: import_zod60.z.number(),
-  system_id: import_zod60.z.number(),
-  constellation_id: import_zod60.z.number(),
-  region_id: import_zod60.z.number(),
-  development_level: import_zod60.z.number().optional(),
-  anarchy_level: import_zod60.z.number().optional(),
-  active_operations: import_zod60.z.number().optional()
-});
-var MercenaryTacticalOperationSchema = import_zod60.z.looseObject({
-  operation_id: import_zod60.z.number(),
-  den_id: import_zod60.z.number(),
-  system_id: import_zod60.z.number(),
-  site_type: import_zod60.z.string(),
-  status: import_zod60.z.enum(["spawning", "active", "completed", "expired"]),
-  started_at: import_zod60.z.string().optional(),
-  expires_at: import_zod60.z.string().optional()
+var import_zod63 = require("zod");
+var MercenaryDenSchema = import_zod63.z.looseObject({
+  den_id: import_zod63.z.number(),
+  system_id: import_zod63.z.number(),
+  constellation_id: import_zod63.z.number(),
+  region_id: import_zod63.z.number(),
+  development_level: import_zod63.z.number().optional(),
+  anarchy_level: import_zod63.z.number().optional(),
+  active_operations: import_zod63.z.number().optional()
+});
+var MercenaryTacticalOperationSchema = import_zod63.z.looseObject({
+  operation_id: import_zod63.z.number(),
+  den_id: import_zod63.z.number(),
+  system_id: import_zod63.z.number(),
+  site_type: import_zod63.z.string(),
+  status: import_zod63.z.enum(["spawning", "active", "completed", "expired"]),
+  started_at: import_zod63.z.string().optional(),
+  expires_at: import_zod63.z.string().optional()
 });
 
 // src/core/endpoints/mercenaryEndpoints.ts
 var mercenaryEndpoints = {
   getMercenaryDens: {
-    path: "mercenary/dens",
+    path: "characters/{characterId}/structures/mercenary-dens",
     method: "GET",
-    requiresAuth: false,
-    responseSchema: import_zod61.z.array(MercenaryDenSchema)
+    requiresAuth: true,
+    pathParams: ["characterId"],
+    responseSchema: import_zod64.z.array(MercenaryDenSchema)
   },
   getMercenaryTacticalOperations: {
-    path: "mercenary/operations",
+    path: "characters/{characterId}/mercenary-tactical-operations",
     method: "GET",
-    requiresAuth: false,
-    responseSchema: import_zod61.z.array(MercenaryTacticalOperationSchema)
+    requiresAuth: true,
+    pathParams: ["characterId"],
+    responseSchema: import_zod64.z.array(MercenaryTacticalOperationSchema)
   }
 };
 
@@ -8079,42 +8282,56 @@ var MercenaryClient = class extends BaseEsiClient {
   /**
    * Retrieves all mercenary dens with their development and anarchy parameters.
    *
+   * @param characterId - The ID of the character to query mercenary dens for
    * @returns A list of mercenary dens
+   * @requires Authentication
    */
-  getMercenaryDens() {
-    return this.api.getMercenaryDens();
+  getMercenaryDens(characterId) {
+    return this.api.getMercenaryDens(characterId);
   }
   /**
    * Retrieves all mercenary tactical operations (MTOs) spawned from mercenary dens.
    *
+   * @param characterId - The ID of the character to query tactical operations for
    * @returns A list of mercenary tactical operations
+   * @requires Authentication
    */
-  getMercenaryTacticalOperations() {
-    return this.api.getMercenaryTacticalOperations();
+  getMercenaryTacticalOperations(characterId) {
+    return this.api.getMercenaryTacticalOperations(characterId);
   }
 };
 
+// src/core/endpoints/accessListEndpoints.ts
+var import_zod66 = require("zod");
+
 // src/schemas/access-lists.ts
-var import_zod62 = require("zod");
-var AccessListEntrySchema = import_zod62.z.looseObject({
-  entity_id: import_zod62.z.number(),
-  entity_type: import_zod62.z.enum(["character", "corporation", "alliance"]),
-  access_type: import_zod62.z.enum(["allowed", "blocked"])
+var import_zod65 = require("zod");
+var AccessListEntrySchema = import_zod65.z.looseObject({
+  entity_id: import_zod65.z.number(),
+  entity_type: import_zod65.z.enum(["character", "corporation", "alliance"]),
+  access_type: import_zod65.z.enum(["allowed", "blocked"])
 });
-var AccessListSchema = import_zod62.z.looseObject({
-  access_list_id: import_zod62.z.number(),
-  name: import_zod62.z.string(),
-  entries: import_zod62.z.array(AccessListEntrySchema)
+var AccessListSchema = import_zod65.z.looseObject({
+  access_list_id: import_zod65.z.number(),
+  name: import_zod65.z.string(),
+  entries: import_zod65.z.array(AccessListEntrySchema)
 });
 
 // src/core/endpoints/accessListEndpoints.ts
 var accessListEndpoints = {
   getAccessList: {
-    path: "access-lists/{accessListId}",
+    path: "characters/{characterId}/access-lists/{accessListId}",
     method: "GET",
     requiresAuth: true,
-    pathParams: ["accessListId"],
+    pathParams: ["characterId", "accessListId"],
     responseSchema: AccessListSchema
+  },
+  getCharacterAccessLists: {
+    path: "characters/{characterId}/access-lists",
+    method: "GET",
+    requiresAuth: true,
+    pathParams: ["characterId"],
+    responseSchema: import_zod66.z.array(AccessListSchema)
   }
 };
 
@@ -8126,11 +8343,165 @@ var AccessListsClient = class extends BaseEsiClient {
   /**
    * Retrieves the contents of an access list (ACL) including all character, corporation, and alliance entries.
    *
+   * @param characterId - The ID of the character who owns the access list
    * @param accessListId - The ID of the access list to retrieve
    * @returns The access list with its entries
+   * @requires Authentication
+   */
+  getAccessList(characterId, accessListId) {
+    return this.api.getAccessList(characterId, accessListId);
+  }
+  /**
+   * Retrieves all access lists for a character.
+   *
+   * @param characterId - The ID of the character
+   * @returns An array of the character's access lists
+   * @requires Authentication
+   */
+  getCharacterAccessLists(characterId) {
+    return this.api.getCharacterAccessLists(characterId);
+  }
+};
+
+// src/core/endpoints/militaryCampaignEndpoints.ts
+var import_zod68 = require("zod");
+
+// src/schemas/military-campaigns.ts
+var import_zod67 = require("zod");
+var MilitaryCampaignSchema = import_zod67.z.looseObject({
+  campaign_id: import_zod67.z.string(),
+  state: import_zod67.z.string(),
+  progress: import_zod67.z.number(),
+  start_time: import_zod67.z.string(),
+  finish_time: import_zod67.z.string().optional()
+});
+var MilitaryCampaignObjectiveSchema = import_zod67.z.looseObject({
+  objective_id: import_zod67.z.string(),
+  campaign_id: import_zod67.z.string(),
+  state: import_zod67.z.string(),
+  progress: import_zod67.z.number(),
+  participants: import_zod67.z.looseObject({
+    total: import_zod67.z.number(),
+    committed: import_zod67.z.number(),
+    contributors: import_zod67.z.number()
+  })
+});
+var CharacterMilitaryCampaignObjectiveSchema = import_zod67.z.looseObject({
+  objective_id: import_zod67.z.string(),
+  campaign_id: import_zod67.z.string(),
+  committed: import_zod67.z.boolean(),
+  contribution: import_zod67.z.number()
+});
+
+// src/core/endpoints/militaryCampaignEndpoints.ts
+var militaryCampaignEndpoints = {
+  getMilitaryCampaigns: {
+    path: "military-campaigns",
+    method: "GET",
+    requiresAuth: false,
+    responseSchema: import_zod68.z.array(MilitaryCampaignSchema)
+  },
+  getMilitaryCampaign: {
+    path: "military-campaigns/{campaignId}",
+    method: "GET",
+    requiresAuth: false,
+    pathParams: ["campaignId"],
+    responseSchema: MilitaryCampaignSchema
+  },
+  getMilitaryCampaignObjectives: {
+    path: "military-campaigns/{campaignId}/objectives",
+    method: "GET",
+    requiresAuth: false,
+    pathParams: ["campaignId"],
+    responseSchema: import_zod68.z.array(MilitaryCampaignObjectiveSchema)
+  },
+  getMilitaryCampaignObjective: {
+    path: "military-campaigns/{campaignId}/objectives/{objectiveId}",
+    method: "GET",
+    requiresAuth: false,
+    pathParams: ["campaignId", "objectiveId"],
+    responseSchema: MilitaryCampaignObjectiveSchema
+  },
+  getCharacterMilitaryCampaignObjectives: {
+    path: "characters/{characterId}/military-campaigns/objectives",
+    method: "GET",
+    requiresAuth: true,
+    pathParams: ["characterId"],
+    responseSchema: import_zod68.z.array(CharacterMilitaryCampaignObjectiveSchema)
+  },
+  getCharacterMilitaryCampaignObjective: {
+    path: "characters/{characterId}/military-campaigns/objectives/{objectiveId}",
+    method: "GET",
+    requiresAuth: true,
+    pathParams: ["characterId", "objectiveId"],
+    responseSchema: CharacterMilitaryCampaignObjectiveSchema
+  }
+};
+
+// src/clients/MilitaryCampaignsClient.ts
+var MilitaryCampaignsClient = class extends BaseEsiClient {
+  constructor(client) {
+    super(client, militaryCampaignEndpoints);
+  }
+  /**
+   * Retrieves a list of all active, completed, and expired military campaigns.
+   *
+   * @returns An array of military campaigns
+   */
+  getMilitaryCampaigns() {
+    return this.api.getMilitaryCampaigns();
+  }
+  /**
+   * Retrieves detailed information about a specific military campaign.
+   *
+   * @param campaignId - The UUID of the military campaign
+   * @returns Detailed information about the campaign
+   */
+  getMilitaryCampaign(campaignId) {
+    return this.api.getMilitaryCampaign(campaignId);
+  }
+  /**
+   * Retrieves all objectives for a specific military campaign.
+   *
+   * @param campaignId - The UUID of the military campaign
+   * @returns An array of objectives for the campaign
+   */
+  getMilitaryCampaignObjectives(campaignId) {
+    return this.api.getMilitaryCampaignObjectives(campaignId);
+  }
+  /**
+   * Retrieves detailed information about a specific objective in a military campaign.
+   *
+   * @param campaignId - The UUID of the military campaign
+   * @param objectiveId - The UUID of the objective
+   * @returns Detailed information about the objective
+   */
+  getMilitaryCampaignObjective(campaignId, objectiveId) {
+    return this.api.getMilitaryCampaignObjective(campaignId, objectiveId);
+  }
+  /**
+   * Retrieves a character's participated objectives across military campaigns.
+   *
+   * @param characterId - The ID of the character
+   * @returns An array of the character's campaign objective participations
+   * @requires Authentication with scope esi.activity.char:read
+   */
+  getCharacterMilitaryCampaignObjectives(characterId) {
+    return this.api.getCharacterMilitaryCampaignObjectives(characterId);
+  }
+  /**
+   * Retrieves a character's participation details for a specific campaign objective.
+   *
+   * @param characterId - The ID of the character
+   * @param objectiveId - The UUID of the objective
+   * @returns The character's participation details for the objective
+   * @requires Authentication with scope esi.activity.char:read
    */
-  getAccessList(accessListId) {
-    return this.api.getAccessList(accessListId);
+  getCharacterMilitaryCampaignObjective(characterId, objectiveId) {
+    return this.api.getCharacterMilitaryCampaignObjective(
+      characterId,
+      objectiveId
+    );
   }
 };
 
@@ -8144,6 +8515,7 @@ var clientFactories = {
   contacts: ContactsClient,
   contracts: ContractsClient,
   corporations: CorporationsClient,
+  corporationProjects: CorporationProjectsClient,
   dogma: DogmaClient,
   factions: FactionClient,
   fittings: FittingsClient,
@@ -8170,6 +8542,7 @@ var clientFactories = {
   freelanceJobs: FreelanceJobsClient,
   skyhooks: SkyhooksClient,
   mercenary: MercenaryClient,
+  militaryCampaigns: MilitaryCampaignsClient,
   accessLists: AccessListsClient
 };
 function createClientInstance(name, apiClient) {
@@ -8988,6 +9361,12 @@ function configureApiClient(client, config) {
     client.setRetryConfig(config.retryConfig);
   } else if (config?.retryAttempts !== void 0) {
     client.setRetryConfig({ maxRetries: config.retryAttempts });
+  } else {
+    client.setRetryConfig({
+      maxRetries: 3,
+      baseDelayMs: 1e3,
+      maxDelayMs: 3e4
+    });
   }
   if (config?.retryStrategy) {
     client.setRetryStrategy(config.retryStrategy);
@@ -9078,6 +9457,9 @@ var EsiClient = class {
   get corporations() {
     return this.getClient("corporations");
   }
+  get corporationProjects() {
+    return this.getClient("corporationProjects");
+  }
   get dogma() {
     return this.getClient("dogma");
   }
@@ -9156,6 +9538,9 @@ var EsiClient = class {
   get mercenary() {
     return this.getClient("mercenary");
   }
+  get militaryCampaigns() {
+    return this.getClient("militaryCampaigns");
+  }
   get accessLists() {
     return this.getClient("accessLists");
   }
@@ -9726,6 +10111,7 @@ __export(schemas_exports, {
   CharacterLocationSchema: () => CharacterLocationSchema,
   CharacterMarketOrderHistorySchema: () => CharacterMarketOrderHistorySchema,
   CharacterMarketOrderSchema: () => CharacterMarketOrderSchema,
+  CharacterMilitaryCampaignObjectiveSchema: () => CharacterMilitaryCampaignObjectiveSchema,
   CharacterOnlineSchema: () => CharacterOnlineSchema,
   CharacterPortraitSchema: () => CharacterPortraitSchema,
   CharacterRoleSchema: () => CharacterRoleSchema,
@@ -9757,6 +10143,9 @@ __export(schemas_exports, {
   CorporationMemberRoleSchema: () => CorporationMemberRoleSchema,
   CorporationMemberTitleSchema: () => CorporationMemberTitleSchema,
   CorporationMemberTrackingSchema: () => CorporationMemberTrackingSchema,
+  CorporationProjectContributionSchema: () => CorporationProjectContributionSchema,
+  CorporationProjectContributorSchema: () => CorporationProjectContributorSchema,
+  CorporationProjectSchema: () => CorporationProjectSchema,
   CorporationRoleHistorySchema: () => CorporationRoleHistorySchema,
   CorporationShareholderSchema: () => CorporationShareholderSchema,
   CorporationStandingSchema: () => StandingSchema,
@@ -9811,6 +10200,13 @@ __export(schemas_exports, {
   MedalSchema: () => MedalSchema,
   MercenaryDenSchema: () => MercenaryDenSchema,
   MercenaryTacticalOperationSchema: () => MercenaryTacticalOperationSchema,
+  MetaChangelogEntrySchema: () => MetaChangelogEntrySchema,
+  MetaChangelogSchema: () => MetaChangelogSchema,
+  MetaCompatibilityDatesSchema: () => MetaCompatibilityDatesSchema,
+  MetaNameSchema: () => MetaNameSchema,
+  MetaStatusSchema: () => MetaStatusSchema,
+  MilitaryCampaignObjectiveSchema: () => MilitaryCampaignObjectiveSchema,
+  MilitaryCampaignSchema: () => MilitaryCampaignSchema,
   MiningLedgerEntrySchema: () => MiningLedgerEntrySchema,
   MiningObserverEntrySchema: () => MiningObserverEntrySchema,
   MiningObserverSchema: () => MiningObserverSchema,
@@ -9864,6 +10260,7 @@ __export(schemas_exports, {
   ClonesClient,
   ContactsClient,
   ContractsClient,
+  CorporationProjectsClient,
   CorporationsClient,
   CustomEsiClient,
   DogmaClient,
@@ -9889,6 +10286,7 @@ __export(schemas_exports, {
   MarketClient,
   MercenaryClient,
   MetaClient,
+  MilitaryCampaignsClient,
   PiClient,
   RateLimiter,
   RequestDeduplicator,
@@ -9912,6 +10310,7 @@ __export(schemas_exports, {
   fetchAllCursorPages,
   fetchPages,
   getDefaultClient,
+  isCircuitOpen,
   isEsiError,
   isForbidden,
   isNotFound,