@lgriffin/esi.ts 7.4.0 → 9.0.0

package/dist/core/pagination/PaginationHandler.js

@@ -1,115 +0,0 @@
-"use strict";
-/**
- * Pagination Handler for ESI API calls
- * Handles pagination with proper error handling and empty page detection
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PaginationHandler = void 0;
-const loggerUtil_1 = require("../logger/loggerUtil");
-const constants_1 = require("../constants");
-const sleep_1 = require("../util/sleep");
-class PaginationHandler {
-    static DEFAULT_OPTIONS = {
-        maxPages: 1000, // Reasonable limit to prevent infinite loops
-        maxRetries: 3,
-        retryDelayMs: 1000,
-        stopOnEmptyPage: true,
-    };
-    /**
-     * Fetch remaining pages (2..totalPages) and combine with first page data.
-     * The caller has already fetched page 1 and knows the total page count.
-     */
-    static async fetchRemainingPages(client, endpoint, method, requiresAuth, firstPageData, totalPages, body, options = {}, pageFetch, templatePath) {
-        const opts = { ...this.DEFAULT_OPTIONS, ...options };
-        const rateLimiter = client.getRateLimiter();
-        const allData = [...firstPageData];
-        const effectiveMaxPage = Math.min(totalPages, opts.maxPages);
-        if (effectiveMaxPage <= 1) {
-            return allData;
-        }
-        (0, loggerUtil_1.logInfo)(`Fetching pages 2-${effectiveMaxPage} for ${endpoint}...`);
-        let consecutiveFailures = 0;
-        for (let page = 2; page <= effectiveMaxPage; page++) {
-            try {
-                if (rateLimiter)
-                    await rateLimiter.checkRateLimit(templatePath, method);
-                const pageData = await this.fetchPageWithRetry(client, endpoint, method, page, requiresAuth, body, opts, pageFetch);
-                consecutiveFailures = 0;
-                if (opts.stopOnEmptyPage && (!pageData || pageData.length === 0)) {
-                    (0, loggerUtil_1.logWarn)(`Page ${page} is empty. Stopping pagination.`);
-                    break;
-                }
-                allData.push(...pageData);
-                (0, loggerUtil_1.logInfo)(`Fetched page ${page}/${effectiveMaxPage} (${pageData.length} items)`);
-            }
-            catch (error) {
-                consecutiveFailures++;
-                (0, loggerUtil_1.logError)(`Failed to fetch page ${page}: ${error instanceof Error ? error.message : String(error)}`);
-                if (consecutiveFailures >= opts.maxRetries) {
-                    (0, loggerUtil_1.logWarn)(`${consecutiveFailures} consecutive failures. Stopping pagination.`);
-                    break;
-                }
-            }
-        }
-        (0, loggerUtil_1.logInfo)(`Pagination complete. Fetched ${allData.length} total items from up to ${effectiveMaxPage} pages.`);
-        return allData;
-    }
-    /**
-     * Fetch a single page with retry logic
-     */
-    static async fetchPageWithRetry(client, endpoint, method, page, requiresAuth, body, options, pageFetch) {
-        let lastError = null;
-        for (let attempt = 1; attempt <= options.maxRetries; attempt++) {
-            try {
-                return await this.fetchSinglePage(client, endpoint, method, page, requiresAuth, body, pageFetch);
-            }
-            catch (error) {
-                lastError = error;
-                (0, loggerUtil_1.logWarn)(`Attempt ${attempt}/${options.maxRetries} failed for page ${page}: ${error instanceof Error ? error.message : String(error)}`);
-                if (attempt < options.maxRetries) {
-                    await (0, sleep_1.sleep)(options.retryDelayMs * attempt);
-                }
-            }
-        }
-        throw (lastError ||
-            new Error(`Failed to fetch page ${page} after ${options.maxRetries} attempts`));
-    }
-    /**
-     * Fetch a single page.
-     * Preserves any existing query params on the endpoint and appends page=N.
-     */
-    static async fetchSinglePage(client, endpoint, method, page, requiresAuth, body, pageFetch) {
-        const separator = endpoint.includes('?') ? '&' : '?';
-        const paginatedEndpoint = `${endpoint}${separator}page=${page}`;
-        if (pageFetch) {
-            (0, loggerUtil_1.logInfo)(`Fetching page ${page} via pipeline: ${paginatedEndpoint}`);
-            return pageFetch(paginatedEndpoint);
-        }
-        const url = `${client.getLink()}/${paginatedEndpoint}`;
-        (0, loggerUtil_1.logInfo)(`Fetching page ${page}: ${url}`);
-        const response = await fetch(url, {
-            method,
-            headers: {
-                accept: 'gzip, deflate, br',
-                'User-Agent': constants_1.USER_AGENT,
-                'X-Compatibility-Date': constants_1.COMPATIBILITY_DATE,
-                ...(requiresAuth
-                    ? { Authorization: client.getAuthorizationHeader() }
-                    : {}),
-            },
-            body: body ? JSON.stringify(body) : undefined,
-        });
-        if (!response.ok) {
-            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-        }
-        let data;
-        try {
-            data = (await response.json());
-        }
-        catch (jsonError) {
-            throw new Error(`Invalid JSON response for page ${page}: ${jsonError instanceof Error ? jsonError.message : String(jsonError)}`);
-        }
-        return Array.isArray(data) ? data : [data];
-    }
-}
-exports.PaginationHandler = PaginationHandler;

package/dist/core/rateLimiter/IRateLimiter.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/rateLimiter/RateLimiter.js

@@ -1,307 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RateLimiter = void 0;
-const esi_rate_limit_groups_generated_1 = require("../endpoints/esi-rate-limit-groups.generated");
-const stringUtil_1 = require("../util/stringUtil");
-const loggerUtil_1 = require("../logger/loggerUtil");
-const sleep_1 = require("../util/sleep");
-function getTokenCost(statusCode) {
-    if (statusCode >= 200 && statusCode < 300)
-        return 2;
-    if (statusCode >= 300 && statusCode < 400)
-        return 1;
-    if (statusCode >= 400 && statusCode < 500)
-        return 5;
-    if (statusCode >= 500 && statusCode < 600)
-        return 0;
-    return 2;
-}
-const DEFAULT_WINDOW_MS = 900_000;
-class RateLimiter {
-    minDelayMs;
-    decelerationThreshold;
-    userKeyExtractor;
-    lastRequestTime = 0;
-    isTestMode = false;
-    errorLimitRemain = 100;
-    errorLimitReset = 0;
-    defaultBuckets = new Map();
-    userBuckets = null;
-    fallbackBucket;
-    lastCleanup = 0;
-    static CLEANUP_INTERVAL_MS = 60_000;
-    constructor(config) {
-        this.minDelayMs = config?.minDelayMs ?? 50;
-        this.decelerationThreshold = config?.decelerationThreshold ?? 0.2;
-        this.userKeyExtractor = config?.userKeyExtractor;
-        if (this.userKeyExtractor) {
-            this.userBuckets = new Map();
-        }
-        this.fallbackBucket = this.createFallbackBucket();
-    }
-    createFallbackBucket() {
-        return {
-            group: '__fallback__',
-            remaining: -1,
-            limit: 0,
-            used: 0,
-            windowSizeMs: DEFAULT_WINDOW_MS,
-            blockedUntil: 0,
-            lastUpdated: 0,
-        };
-    }
-    createBucketFromSpec(spec) {
-        return {
-            group: spec.group,
-            remaining: spec.maxTokens,
-            limit: spec.maxTokens,
-            used: 0,
-            windowSizeMs: spec.windowSizeMs,
-            blockedUntil: 0,
-            lastUpdated: 0,
-        };
-    }
-    createBucketForGroup(groupName) {
-        return {
-            group: groupName,
-            remaining: -1,
-            limit: 0,
-            used: 0,
-            windowSizeMs: DEFAULT_WINDOW_MS,
-            blockedUntil: 0,
-            lastUpdated: 0,
-        };
-    }
-    lookupGroupSpec(method, templatePath) {
-        if (!templatePath || !method)
-            return undefined;
-        const normalized = templatePath
-            .replace(/\/$/, '')
-            .replace(/\{(\w+)\}/g, (_, name) => `{${(0, stringUtil_1.camelToSnake)(name)}}`);
-        const key = `${method}:${normalized}`;
-        return esi_rate_limit_groups_generated_1.esiRateLimitGroups[key];
-    }
-    resolveBucketMap(requestHeaders) {
-        if (!this.userBuckets || !this.userKeyExtractor || !requestHeaders) {
-            return this.defaultBuckets;
-        }
-        const userKey = this.userKeyExtractor(requestHeaders);
-        let userSet = this.userBuckets.get(userKey);
-        if (!userSet) {
-            userSet = { groups: new Map(), lastAccessed: Date.now() };
-            this.userBuckets.set(userKey, userSet);
-        }
-        userSet.lastAccessed = Date.now();
-        return userSet.groups;
-    }
-    getBucket(templatePath, method, requestHeaders, groupNameOverride) {
-        const bucketMap = this.resolveBucketMap(requestHeaders);
-        const spec = this.lookupGroupSpec(method, templatePath);
-        const groupName = groupNameOverride ?? spec?.group;
-        if (!groupName)
-            return this.fallbackBucket;
-        let bucket = bucketMap.get(groupName);
-        if (!bucket) {
-            bucket = spec
-                ? this.createBucketFromSpec(spec)
-                : this.createBucketForGroup(groupName);
-            bucketMap.set(groupName, bucket);
-        }
-        return bucket;
-    }
-    cleanupStaleUsers() {
-        if (!this.userBuckets)
-            return;
-        const now = Date.now();
-        if (now - this.lastCleanup < RateLimiter.CLEANUP_INTERVAL_MS)
-            return;
-        this.lastCleanup = now;
-        for (const [userKey, userSet] of this.userBuckets) {
-            if (now - userSet.lastAccessed > DEFAULT_WINDOW_MS) {
-                this.userBuckets.delete(userKey);
-            }
-        }
-    }
-    updateFromResponse(headers, statusCode, templatePath, method, requestHeaders) {
-        if (this.isTestMode)
-            return;
-        const responseGroup = headers['x-ratelimit-group'] || undefined;
-        const bucket = this.getBucket(templatePath, method, requestHeaders, responseGroup);
-        if ('x-ratelimit-remaining' in headers) {
-            bucket.remaining = parseInt(headers['x-ratelimit-remaining'], 10);
-        }
-        if ('x-ratelimit-limit' in headers) {
-            bucket.limit = parseInt(headers['x-ratelimit-limit'], 10);
-        }
-        if ('x-ratelimit-used' in headers) {
-            bucket.used = parseInt(headers['x-ratelimit-used'], 10);
-        }
-        bucket.lastUpdated = Date.now();
-        if ('retry-after' in headers) {
-            const retrySeconds = parseInt(headers['retry-after'], 10);
-            bucket.blockedUntil = Date.now() + retrySeconds * 1000;
-        }
-        if (statusCode === 420 || statusCode === 429) {
-            if (bucket.blockedUntil <= Date.now()) {
-                bucket.blockedUntil = Date.now() + 60_000;
-            }
-        }
-        if ('x-esi-error-limit-remain' in headers) {
-            this.errorLimitRemain = parseInt(headers['x-esi-error-limit-remain'], 10);
-        }
-        if ('x-esi-error-limit-reset' in headers) {
-            this.errorLimitReset = parseInt(headers['x-esi-error-limit-reset'], 10);
-        }
-    }
-    updateRateLimitInfo(headers) {
-        this.updateFromResponse(headers, 200);
-    }
-    async checkRateLimit(templatePath, method, requestHeaders) {
-        if (this.isTestMode)
-            return;
-        this.cleanupStaleUsers();
-        const bucket = this.getBucket(templatePath, method, requestHeaders);
-        const now = Date.now();
-        if (bucket.blockedUntil > now) {
-            const waitTime = bucket.blockedUntil - now;
-            (0, loggerUtil_1.logWarn)(`[ESI Rate Limit] Group '${bucket.group}' blocked for ${Math.ceil(waitTime / 1000)}s (420/429 received)`);
-            await (0, sleep_1.sleep)(waitTime);
-            bucket.blockedUntil = 0;
-            return;
-        }
-        if (this.errorLimitRemain <= 10 && this.errorLimitRemain > 0) {
-            const resetMs = this.errorLimitReset * 1000;
-            const delay = Math.min(resetMs, 5000);
-            if (delay > 0) {
-                (0, loggerUtil_1.logWarn)(`[ESI Rate Limit] Legacy error limit low (${this.errorLimitRemain}), waiting ${delay}ms`);
-                await (0, sleep_1.sleep)(delay);
-                return;
-            }
-        }
-        if (this.errorLimitRemain <= 0 && this.errorLimitReset > 0) {
-            const waitTime = this.errorLimitReset * 1000;
-            (0, loggerUtil_1.logWarn)(`[ESI Rate Limit] Legacy error limit exhausted, waiting ${Math.ceil(waitTime / 1000)}s`);
-            await (0, sleep_1.sleep)(waitTime);
-            return;
-        }
-        if (bucket.remaining >= 0 && bucket.limit > 0) {
-            const ratio = bucket.remaining / bucket.limit;
-            if (bucket.remaining <= 0) {
-                (0, loggerUtil_1.logWarn)(`[ESI Rate Limit] Group '${bucket.group}' token bucket empty, waiting 1s`);
-                await (0, sleep_1.sleep)(1000);
-                return;
-            }
-            if (ratio <= this.decelerationThreshold) {
-                const extraDelay = Math.ceil((1 - ratio / this.decelerationThreshold) * 1000);
-                await (0, sleep_1.sleep)(extraDelay);
-                return;
-            }
-        }
-        await this.enforceMinDelay();
-    }
-    async enforceMinDelay() {
-        if (this.isTestMode) {
-            this.lastRequestTime = Date.now();
-            return;
-        }
-        const now = Date.now();
-        const timeSinceLastRequest = now - this.lastRequestTime;
-        if (timeSinceLastRequest < this.minDelayMs) {
-            await (0, sleep_1.sleep)(this.minDelayMs - timeSinceLastRequest);
-        }
-        this.lastRequestTime = Date.now();
-    }
-    getStatus() {
-        let worstBucket = this.fallbackBucket;
-        let worstRatio = Infinity;
-        const checkBucket = (bucket) => {
-            if (bucket.limit > 0) {
-                const ratio = bucket.remaining / bucket.limit;
-                if (ratio < worstRatio) {
-                    worstRatio = ratio;
-                    worstBucket = bucket;
-                }
-            }
-        };
-        for (const bucket of this.defaultBuckets.values()) {
-            checkBucket(bucket);
-        }
-        if (this.userBuckets) {
-            for (const userSet of this.userBuckets.values()) {
-                for (const bucket of userSet.groups.values()) {
-                    checkBucket(bucket);
-                }
-            }
-        }
-        return {
-            remaining: worstBucket.remaining,
-            limit: worstBucket.limit,
-            used: worstBucket.used,
-            group: worstBucket.group === '__fallback__' ? null : worstBucket.group,
-            errorLimitRemain: this.errorLimitRemain,
-            errorLimitReset: this.errorLimitReset,
-            retryAfter: worstBucket.blockedUntil > Date.now()
-                ? Math.ceil((worstBucket.blockedUntil - Date.now()) / 1000)
-                : null,
-            blockedUntil: worstBucket.blockedUntil,
-        };
-    }
-    getGroupStatus(group) {
-        const bucket = this.defaultBuckets.get(group);
-        if (!bucket)
-            return undefined;
-        return {
-            group: bucket.group,
-            remaining: bucket.remaining,
-            limit: bucket.limit,
-            used: bucket.used,
-            windowSizeMs: bucket.windowSizeMs,
-            blockedUntil: bucket.blockedUntil,
-        };
-    }
-    getAllGroupStatuses() {
-        const result = new Map();
-        for (const [name, bucket] of this.defaultBuckets) {
-            result.set(name, {
-                group: bucket.group,
-                remaining: bucket.remaining,
-                limit: bucket.limit,
-                used: bucket.used,
-                windowSizeMs: bucket.windowSizeMs,
-                blockedUntil: bucket.blockedUntil,
-            });
-        }
-        return result;
-    }
-    static getTokenCost(statusCode) {
-        return getTokenCost(statusCode);
-    }
-    isBlocked(group) {
-        const now = Date.now();
-        if (group) {
-            const bucket = this.defaultBuckets.get(group);
-            return bucket ? bucket.blockedUntil > now : false;
-        }
-        if (this.fallbackBucket.blockedUntil > now)
-            return true;
-        for (const bucket of this.defaultBuckets.values()) {
-            if (bucket.blockedUntil > now)
-                return true;
-        }
-        return false;
-    }
-    setTestMode(enabled) {
-        this.isTestMode = enabled;
-    }
-    reset() {
-        this.defaultBuckets.clear();
-        if (this.userBuckets)
-            this.userBuckets.clear();
-        this.fallbackBucket = this.createFallbackBucket();
-        this.errorLimitRemain = 100;
-        this.errorLimitReset = 0;
-        this.lastRequestTime = 0;
-        this.lastCleanup = 0;
-    }
-}
-exports.RateLimiter = RateLimiter;

package/dist/core/util/error.js

@@ -1,122 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EsiValidationError = exports.buildError = exports.TimeoutError = exports.EsiError = void 0;
-exports.isEsiError = isEsiError;
-exports.isRateLimited = isRateLimited;
-exports.isNotFound = isNotFound;
-exports.isUnauthorized = isUnauthorized;
-exports.isForbidden = isForbidden;
-exports.isServerError = isServerError;
-exports.isTimeout = isTimeout;
-exports.isRetryable = isRetryable;
-exports.isValidationError = isValidationError;
-function sanitizeUrl(url) {
-    if (!url)
-        return url;
-    try {
-        const parsed = new URL(url);
-        const sensitiveParams = ['token', 'access_token', 'api_key'];
-        for (const param of sensitiveParams) {
-            if (parsed.searchParams.has(param)) {
-                parsed.searchParams.set(param, '[REDACTED]');
-            }
-        }
-        return parsed.toString();
-    }
-    catch {
-        const qIndex = url.indexOf('?');
-        return qIndex >= 0 ? url.substring(0, qIndex) + '?[params-redacted]' : url;
-    }
-}
-class EsiError extends Error {
-    statusCode;
-    requestId;
-    url;
-    constructor(statusCode, message, url, requestId) {
-        super(message);
-        this.statusCode = statusCode;
-        this.requestId = requestId;
-        this.name = 'EsiError';
-        this.url = sanitizeUrl(url);
-    }
-    isRateLimited() {
-        return this.statusCode === 420 || this.statusCode === 429;
-    }
-    isNotFound() {
-        return this.statusCode === 404;
-    }
-    isUnauthorized() {
-        return this.statusCode === 401;
-    }
-    isForbidden() {
-        return this.statusCode === 403;
-    }
-    isServerError() {
-        return this.statusCode >= 500;
-    }
-    isTimeout() {
-        return this.statusCode === 0;
-    }
-    get retryable() {
-        return (this.statusCode === 0 ||
-            this.statusCode === 420 ||
-            this.statusCode === 429 ||
-            this.statusCode === 502 ||
-            this.statusCode === 503 ||
-            this.statusCode === 504);
-    }
-}
-exports.EsiError = EsiError;
-function isEsiError(error) {
-    return error instanceof EsiError;
-}
-function isRateLimited(error) {
-    return error instanceof EsiError && error.isRateLimited();
-}
-function isNotFound(error) {
-    return error instanceof EsiError && error.isNotFound();
-}
-function isUnauthorized(error) {
-    return error instanceof EsiError && error.isUnauthorized();
-}
-function isForbidden(error) {
-    return error instanceof EsiError && error.isForbidden();
-}
-function isServerError(error) {
-    return error instanceof EsiError && error.isServerError();
-}
-class TimeoutError extends EsiError {
-    timeoutMs;
-    constructor(timeoutMs, url, requestId) {
-        super(0, `Request timed out after ${timeoutMs}ms`, url, requestId);
-        this.timeoutMs = timeoutMs;
-        this.name = 'TimeoutError';
-    }
-}
-exports.TimeoutError = TimeoutError;
-function isTimeout(error) {
-    return error instanceof TimeoutError;
-}
-function isRetryable(error) {
-    return error instanceof EsiError && error.retryable;
-}
-const buildError = (message, type = 'ERROR', url) => {
-    const error = new Error(`[${type}] ${message}`);
-    if (url) {
-        error.url = url;
-    }
-    return error;
-};
-exports.buildError = buildError;
-class EsiValidationError extends EsiError {
-    validationError;
-    constructor(url, zodError, requestId) {
-        super(0, `Response validation failed for ${url}`, url, requestId);
-        this.name = 'EsiValidationError';
-        this.validationError = zodError;
-    }
-}
-exports.EsiValidationError = EsiValidationError;
-function isValidationError(error) {
-    return error instanceof EsiValidationError;
-}

package/dist/core/util/headersUtil.js

@@ -1,37 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseWarning = parseWarning;
-exports.parseHeaders = parseHeaders;
-function parseWarning(value) {
-    if (!value)
-        return null;
-    const match = /^(\d{3}) - "([^"]+)"$/.exec(value) ??
-        /^(\d{3}) - ([^ ].+[^ ])$/.exec(value);
-    if (!match)
-        return null;
-    const [, code, message] = match;
-    return { code: parseInt(code, 10), message: message };
-}
-function parseHeaders(fetchHeaders) {
-    const raw = {};
-    fetchHeaders.forEach((value, key) => {
-        raw[key.toLowerCase()] = value;
-    });
-    const cursorBefore = raw['x-cursor-before'] ?? null;
-    const cursorAfter = raw['x-cursor-after'] ?? null;
-    return {
-        raw,
-        xPages: parseInt(raw['x-pages'] ?? '1', 10),
-        etag: raw['etag'] ?? null,
-        cacheControl: raw['cache-control'] ?? null,
-        expires: raw['expires'] ?? null,
-        lastModified: raw['last-modified'] ?? null,
-        cursorBefore,
-        cursorAfter,
-        hasCursorPagination: 'x-cursor-before' in raw || 'x-cursor-after' in raw,
-        warning: parseWarning(raw['warning']),
-        requestId: raw['x-esi-request-id'] ?? null,
-        date: raw['date'] ?? null,
-        contentLanguage: raw['content-language'] ?? null,
-    };
-}

package/dist/core/util/retry.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.retryDelay = retryDelay;
-function retryDelay(attempt, baseMs, maxMs) {
-    const exponential = baseMs * Math.pow(2, attempt);
-    // eslint-disable-next-line sonarjs/pseudo-random
-    const jitter = exponential * (0.75 + Math.random() * 0.5);
-    return Math.min(jitter, maxMs);
-}

package/dist/core/util/sleep.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sleep = sleep;
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}

package/dist/core/util/stringUtil.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.camelToSnake = camelToSnake;
-function camelToSnake(s) {
-    return s.replace(/[A-Z]/g, (c) => `_${c.toLowerCase()}`);
-}

package/dist/core/util/testHelpers.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getBody = void 0;
-/* eslint-disable @typescript-eslint/no-explicit-any */
-const getBody = async (apiCall) => {
-    return apiCall();
-};
-exports.getBody = getBody;
-/* eslint-enable @typescript-eslint/no-explicit-any */

package/dist/core/util/validation.js

@@ -1,52 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validatePathParam = validatePathParam;
-exports.validateBaseUrl = validateBaseUrl;
-exports.validateQueryParam = validateQueryParam;
-const error_1 = require("./error");
-const UNSAFE_PATH_CHARS = /[/\\?#@!$&'()*+,;=<>{}|^`]/;
-function validatePathParam(paramName, value) {
-    if (value === null || value === undefined || value === '') {
-        throw (0, error_1.buildError)(`Path parameter '${paramName}' must not be empty`, 'VALIDATION_ERROR');
-    }
-    const str = `${value}`;
-    if (UNSAFE_PATH_CHARS.test(str)) {
-        throw (0, error_1.buildError)(`Path parameter '${paramName}' contains invalid characters`, 'VALIDATION_ERROR');
-    }
-    if (typeof value === 'number' && !Number.isFinite(value)) {
-        throw (0, error_1.buildError)(`Path parameter '${paramName}' must be a finite number`, 'VALIDATION_ERROR');
-    }
-    return str;
-}
-const ALLOWED_ESI_HOSTS = ['esi.evetech.net'];
-function validateBaseUrl(url, allowCustomHost) {
-    let parsed;
-    try {
-        parsed = new URL(url);
-    }
-    catch {
-        throw (0, error_1.buildError)(`Invalid base URL: ${url}`, 'VALIDATION_ERROR');
-    }
-    if (parsed.protocol !== 'https:') {
-        throw (0, error_1.buildError)('Base URL must use HTTPS protocol', 'VALIDATION_ERROR');
-    }
-    if (!allowCustomHost && !ALLOWED_ESI_HOSTS.includes(parsed.hostname)) {
-        throw (0, error_1.buildError)(`Base URL host '${parsed.hostname}' is not in the allowlist. ` +
-            `Allowed hosts: ${ALLOWED_ESI_HOSTS.join(', ')}. ` +
-            `Set unsafeAllowCustomHost to bypass this check.`, 'VALIDATION_ERROR');
-    }
-    return url.replace(/\/$/, '');
-}
-function validateQueryParam(paramName, value) {
-    if (value === null || value === undefined) {
-        throw (0, error_1.buildError)(`Query parameter '${paramName}' must not be null or undefined`, 'VALIDATION_ERROR');
-    }
-    const str = `${value}`;
-    if (typeof value === 'number' && !Number.isFinite(value)) {
-        throw (0, error_1.buildError)(`Query parameter '${paramName}' must be a finite number`, 'VALIDATION_ERROR');
-    }
-    if (str.length > 2000) {
-        throw (0, error_1.buildError)(`Query parameter '${paramName}' exceeds maximum length`, 'VALIDATION_ERROR');
-    }
-    return str;
-}

package/dist/schemas/access-lists.js

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AccessListSchema = exports.AccessListEntrySchema = void 0;
-const zod_1 = require("zod");
-exports.AccessListEntrySchema = zod_1.z.looseObject({
-    entity_id: zod_1.z.number(),
-    entity_type: zod_1.z.enum(['character', 'corporation', 'alliance']),
-    access_type: zod_1.z.enum(['allowed', 'blocked']),
-});
-exports.AccessListSchema = zod_1.z.looseObject({
-    access_list_id: zod_1.z.number(),
-    name: zod_1.z.string(),
-    entries: zod_1.z.array(exports.AccessListEntrySchema),
-});