@gala-chain/launchpad-sdk 5.0.3 → 5.0.4-beta.0

package/dist/src/services/AbstractCacheService.d.ts

@@ -0,0 +1,227 @@
+/**
+ * Abstract Cache Service Base Class
+ *
+ * Provides generic cache management functionality for all cache implementations.
+ * Eliminates duplication across BridgeableTokenCache, WrappableTokenCache, and TokenMetadataCache
+ * by providing a common interface and lifecycle management.
+ *
+ * ## Architecture
+ * - **Generic K/V types**: Supports any key/value structure
+ * - **Key normalization**: Abstract method for consistent key generation
+ * - **Common operations**: Get, set, has, clear, stats, dump
+ * - **Logging support**: Integrated with LoggerBase for debug output
+ *
+ * ## Subclass Responsibilities
+ * - Implement `normalizeKey()` for domain-specific key normalization
+ * - Override specific methods if custom behavior needed (e.g., merge, multiple indices)
+ * - Implement typed statistics interface extending `BaseCacheStats`
+ *
+ * @category Services
+ * @since 3.34.0
+ * @template K - Key type (string, number, etc.)
+ * @template V - Value type (token, metadata, etc.)
+ */
+import { LoggerBase } from './BaseService.js';
+/**
+ * Base cache statistics interface
+ *
+ * All cache implementations should extend this with domain-specific stats.
+ */
+export interface BaseCacheStats {
+    /** Total number of items in cache */
+    totalItems: number;
+}
+/**
+ * Abstract cache service with generic key/value support
+ *
+ * Provides reusable cache lifecycle management for all cache implementations.
+ * Subclasses implement domain-specific normalization and optional enhancements.
+ *
+ * @template K - Key type for cache lookups
+ * @template V - Value type stored in cache
+ * @template S - Statistics type (must extend BaseCacheStats)
+ *
+ * @example Implementing a simple cache
+ * ```typescript
+ * import { normalizeTokenKey } from '../utils/tokenNameNormalizer';
+ *
+ * interface UserData {
+ *   id: string;
+ *   name: string;
+ * }
+ *
+ * interface UserCacheStats extends BaseCacheStats {
+ *   userCount: number;
+ *   lastUpdated: number;
+ * }
+ *
+ * class UserCache extends AbstractCacheService<string, UserData, UserCacheStats> {
+ *   private lastUpdated = 0;
+ *
+ *   protected normalizeKey(key: string): string {
+ *     // Use normalizeTokenKey() for case-insensitive cache lookups
+ *     return normalizeTokenKey(key);
+ *   }
+ *
+ *   getStats(): UserCacheStats {
+ *     return {
+ *       totalItems: this.cache.size,
+ *       userCount: this.cache.size,
+ *       lastUpdated: this.lastUpdated,
+ *     };
+ *   }
+ * }
+ * ```
+ */
+export declare abstract class AbstractCacheService<K, V, S extends BaseCacheStats = BaseCacheStats> extends LoggerBase {
+    /** Primary cache storage */
+    protected cache: Map<string, V>;
+    constructor(debugMode?: boolean);
+    /**
+     * Normalize a key for consistent cache lookups
+     *
+     * Subclasses MUST implement this to handle domain-specific normalization.
+     * Use provided utilities from tokenNameNormalizer.ts for consistency:
+     * - `normalizeTokenKey()`: Trim + uppercase (for symbols, tokenIds, cache keys)
+     * - `normalizeTokenName()`: Trim + lowercase (for launchpad token names)
+     *
+     * @param key - Raw key to normalize
+     * @returns Normalized key string for Map lookups
+     *
+     * @example Token cache (symbols/tokenIds) - use normalizeTokenKey()
+     * ```typescript
+     * import { normalizeTokenKey } from '../utils/tokenNameNormalizer';
+     *
+     * protected normalizeKey(key: string): string {
+     *   // For cache keys: uppercase for case-insensitive lookups
+     *   return normalizeTokenKey(key);
+     * }
+     * ```
+     *
+     * @example Token name cache (backend format) - use normalizeTokenName()
+     * ```typescript
+     * import { normalizeTokenName } from '../utils/tokenNameNormalizer';
+     *
+     * protected normalizeKey(tokenName: string): string {
+     *   // For launchpad token names: lowercase to match backend storage
+     *   return normalizeTokenName(tokenName);
+     * }
+     * ```
+     */
+    protected abstract normalizeKey(key: K): string;
+    /**
+     * Get a value from cache
+     *
+     * @param key - Key to look up (normalized internally)
+     * @returns Value if found, undefined if not cached
+     *
+     * @example Basic retrieval
+     * ```typescript
+     * const token = cache.get('ethereum');
+     * if (token) {
+     *   console.log('Found:', token);
+     * }
+     * ```
+     */
+    get(key: K): V | undefined;
+    /**
+     * Set a value in cache
+     *
+     * @param key - Key to store under (normalized internally)
+     * @param value - Value to cache
+     *
+     * @example Basic storage
+     * ```typescript
+     * cache.set('ethereum', ethereumTokens);
+     * ```
+     */
+    set(key: K, value: V): void;
+    /**
+     * Check if a key exists in cache
+     *
+     * @param key - Key to check (normalized internally)
+     * @returns True if key exists and has a value
+     *
+     * @example Existence check
+     * ```typescript
+     * if (cache.has('ethereum')) {
+     *   const tokens = cache.get('ethereum');
+     * }
+     * ```
+     */
+    has(key: K): boolean;
+    /**
+     * Clear entire cache
+     *
+     * Resets all stored values. Override in subclasses for additional cleanup
+     * (e.g., clearing secondary indices, resetting timestamps).
+     *
+     * @example Clear cache
+     * ```typescript
+     * cache.clear();
+     * ```
+     */
+    clear(): void;
+    /**
+     * Get cache statistics
+     *
+     * Subclasses MUST implement this to return domain-specific statistics.
+     * Always include totalItems for monitoring purposes.
+     *
+     * @returns Statistics object with cache metrics
+     *
+     * @example Retrieving stats
+     * ```typescript
+     * const stats = cache.getStats();
+     * console.log(`Cached ${stats.totalItems} items`);
+     * ```
+     */
+    abstract getStats(): S;
+    /**
+     * Export entire cache contents
+     *
+     * Returns a Map of all cached key/value pairs. Useful for debugging,
+     * monitoring, and testing. Does not include secondary indices.
+     *
+     * @returns Shallow copy of cache contents
+     *
+     * @example Export cache
+     * ```typescript
+     * const contents = cache.dump();
+     * console.log('Cache contents:', Array.from(contents.entries()));
+     * ```
+     */
+    dump(): Map<string, V>;
+    /**
+     * Get number of items in cache
+     *
+     * @returns Count of cached items
+     */
+    size(): number;
+    /**
+     * Check if cache is empty
+     *
+     * @returns True if no items are cached
+     */
+    isEmpty(): boolean;
+    /**
+     * Build base statistics (helper for subclasses)
+     *
+     * Provides the common totalItems field that all caches need.
+     * Subclasses can extend this with domain-specific stats.
+     *
+     * @returns Base statistics with totalItems
+     *
+     * @example Extending in subclass
+     * ```typescript
+     * public getStats(): MyCacheStats {
+     *   return {
+     *     ...this.buildBaseStats(),
+     *     customMetric: this.calculateCustomMetric(),
+     *   };
+     * }
+     * ```
+     */
+    protected buildBaseStats(): BaseCacheStats;
+}
+//# sourceMappingURL=AbstractCacheService.d.ts.map

package/dist/src/services/AbstractCacheService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AbstractCacheService.d.ts","sourceRoot":"","sources":["../../../src/services/AbstractCacheService.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAE9C;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC7B,qCAAqC;IACrC,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,8BAAsB,oBAAoB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,SAAS,cAAc,GAAG,cAAc,CAAE,SAAQ,UAAU;IAC5G,4BAA4B;IAC5B,SAAS,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,CAAC,CAAC,CAAa;gBAEhC,SAAS,GAAE,OAAe;IAItC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,SAAS,CAAC,QAAQ,CAAC,YAAY,CAAC,GAAG,EAAE,CAAC,GAAG,MAAM;IAE/C;;;;;;;;;;;;;OAaG;IACI,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS;IAKjC;;;;;;;;;;OAUG;IACI,GAAG,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI;IAKlC;;;;;;;;;;;;OAYG;IACI,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO;IAK3B;;;;;;;;;;OAUG;IACI,KAAK,IAAI,IAAI;IAKpB;;;;;;;;;;;;;OAaG;aACa,QAAQ,IAAI,CAAC;IAE7B;;;;;;;;;;;;;OAaG;IACI,IAAI,IAAI,GAAG,CAAC,MAAM,EAAE,CAAC,CAAC;IAI7B;;;;OAIG;IACI,IAAI,IAAI,MAAM;IAIrB;;;;OAIG;IACI,OAAO,IAAI,OAAO;IAIzB;;;;;;;;;;;;;;;;;OAiBG;IACH,SAAS,CAAC,cAAc,IAAI,cAAc;CAK3C"}

package/dist/src/services/AbstractTokenFetchService.d.ts

@@ -0,0 +1,150 @@
+/**
+ * Abstract Token Fetch Service Base Class
+ *
+ * Provides common patterns for services that fetch and cache token data
+ * from the DEX API with pagination support.
+ *
+ * ## Features
+ * - Paginated fetch with offset/limit
+ * - Auto-pagination via autoPaginateOffset
+ * - Cache integration (via subclass-provided cache)
+ * - Response transformation abstraction
+ * - Common error handling
+ *
+ * ## Subclass Responsibilities
+ * - Implement `buildApiParams()` for API-specific parameters
+ * - Implement `transformApiResponse()` for response transformation
+ * - Implement cache-specific methods (network-keyed or simple)
+ * - Provide domain-specific public API methods
+ *
+ * ## Key Pattern
+ * This base class consolidates ~150 lines of duplicate code between
+ * BridgeableTokenService and WrappableTokenService by abstracting:
+ * - API request structure
+ * - Pagination handling
+ * - Cache warming patterns
+ * - Error handling
+ *
+ * @category Services
+ * @since 5.11.0
+ * @template TApiResponse - Raw API response item type
+ * @template TToken - Transformed token type for SDK use
+ */
+import { HttpClient } from '../utils/http.js';
+import { Logger } from '../utils/Logger.js';
+import type { OffsetPaginationFetchResult } from '../utils/auto-pagination.js';
+/** Maximum tokens per API request (backend limit) */
+export declare const DEFAULT_MAX_LIMIT = 1000;
+/** Default limit for paginated requests */
+export declare const DEFAULT_LIMIT = 1000;
+/**
+ * Base options for paginated token fetches
+ */
+export interface BaseTokenFetchOptions {
+    /** Offset for pagination (default: 0) */
+    offset?: number;
+    /** Limit per page (default: 1000, max: 1000) */
+    limit?: number;
+}
+/**
+ * Base result for paginated token fetches
+ */
+export interface BaseTokenFetchResult<T> {
+    /** Array of transformed tokens */
+    tokens: T[];
+    /** Timestamp when data was fetched */
+    fetchedAt: number;
+    /** Number of tokens returned */
+    tokenCount: number;
+}
+/**
+ * API response wrapper type (tokens array in response)
+ */
+export interface TokensApiResponse<TApiResponse> {
+    tokens: TApiResponse[];
+}
+/**
+ * Abstract base class for token fetch services
+ *
+ * Consolidates common patterns for fetching and caching token data
+ * from the DEX API. Subclasses provide API-specific parameters and
+ * transformation logic.
+ *
+ * @template TApiResponse - Raw API response item type
+ * @template TToken - Transformed token type for SDK use
+ */
+export declare abstract class AbstractTokenFetchService<TApiResponse, TToken> {
+    protected readonly dexApiHttp: HttpClient;
+    protected readonly logger: Logger;
+    constructor(dexApiHttp: HttpClient, debugMode?: boolean, loggerContext?: string);
+    /**
+     * Build API request parameters
+     *
+     * Subclasses implement this to add API-specific query parameters.
+     * The context parameter allows passing request-specific data (e.g., network)
+     * to avoid race conditions with mutable instance state.
+     *
+     * @param context - Optional context for building parameters (e.g., { network: 'ETHEREUM' })
+     * @returns Record of query parameters for the API request
+     */
+    protected abstract buildApiParams(context?: Record<string, unknown>): Record<string, string | number | boolean>;
+    /**
+     * Transform API response items to SDK format
+     *
+     * Subclasses implement this to convert raw API responses to typed SDK objects.
+     *
+     * @param apiTokens - Raw API response tokens
+     * @returns Array of transformed tokens
+     */
+    protected abstract transformApiResponse(apiTokens: TApiResponse[]): TToken[];
+    /**
+     * Get the API endpoint URL
+     *
+     * @returns API endpoint path (default: /v1/tokens)
+     */
+    protected getApiEndpoint(): string;
+    /**
+     * Get the maximum limit for API requests
+     *
+     * @returns Maximum items per request
+     */
+    protected getMaxLimit(): number;
+    /**
+     * Get the default limit for API requests
+     *
+     * @returns Default items per request
+     */
+    protected getDefaultLimit(): number;
+    /**
+     * Execute a paginated API request
+     *
+     * Core method that performs the HTTP request with pagination parameters.
+     * Used by both single-page and auto-paginated fetches.
+     *
+     * @param offset - Offset for pagination
+     * @param limit - Number of items to fetch
+     * @param context - Optional context for building parameters (e.g., { network: 'ETHEREUM' })
+     * @returns Promise resolving to transformed tokens
+     * @throws ValidationError if API response structure is invalid
+     */
+    protected executePaginatedRequest(offset: number, limit: number, context?: Record<string, unknown>): Promise<OffsetPaginationFetchResult<TToken>>;
+    /**
+     * Auto-paginate through all API results
+     *
+     * Fetches all pages of results automatically.
+     * Subclasses call this from their fetchAll methods.
+     *
+     * @param context - Optional context for building parameters (e.g., { network: 'ETHEREUM' })
+     * @returns Promise resolving to all transformed tokens
+     */
+    protected autoPaginateFetch(context?: Record<string, unknown>): Promise<TToken[]>;
+    /**
+     * Handle API errors consistently
+     *
+     * @param error - Error from API call
+     * @param message - Error message prefix
+     * @throws Transformed error with proper type
+     */
+    protected handleError(error: unknown, message: string): never;
+}
+//# sourceMappingURL=AbstractTokenFetchService.d.ts.map

package/dist/src/services/AbstractTokenFetchService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AbstractTokenFetchService.d.ts","sourceRoot":"","sources":["../../../src/services/AbstractTokenFetchService.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAK5C,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,6BAA6B,CAAC;AAE/E,qDAAqD;AACrD,eAAO,MAAM,iBAAiB,OAAO,CAAC;AAEtC,2CAA2C;AAC3C,eAAO,MAAM,aAAa,OAAO,CAAC;AAElC;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,yCAAyC;IACzC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,gDAAgD;IAChD,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB,CAAC,CAAC;IACrC,kCAAkC;IAClC,MAAM,EAAE,CAAC,EAAE,CAAC;IACZ,sCAAsC;IACtC,SAAS,EAAE,MAAM,CAAC;IAClB,gCAAgC;IAChC,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB,CAAC,YAAY;IAC7C,MAAM,EAAE,YAAY,EAAE,CAAC;CACxB;AAED;;;;;;;;;GASG;AACH,8BAAsB,yBAAyB,CAAC,YAAY,EAAE,MAAM;IAIhE,SAAS,CAAC,QAAQ,CAAC,UAAU,EAAE,UAAU;IAH3C,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;gBAGb,UAAU,EAAE,UAAU,EACzC,SAAS,GAAE,OAAe,EAC1B,aAAa,CAAC,EAAE,MAAM;IAQxB;;;;;;;;;OASG;IACH,SAAS,CAAC,QAAQ,CAAC,cAAc,CAC/B,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAChC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;IAE5C;;;;;;;OAOG;IACH,SAAS,CAAC,QAAQ,CAAC,oBAAoB,CAAC,SAAS,EAAE,YAAY,EAAE,GAAG,MAAM,EAAE;IAE5E;;;;OAIG;IACH,SAAS,CAAC,cAAc,IAAI,MAAM;IAIlC;;;;OAIG;IACH,SAAS,CAAC,WAAW,IAAI,MAAM;IAI/B;;;;OAIG;IACH,SAAS,CAAC,eAAe,IAAI,MAAM;IAInC;;;;;;;;;;;OAWG;cACa,uBAAuB,CACrC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAChC,OAAO,CAAC,2BAA2B,CAAC,MAAM,CAAC,CAAC;IA+B/C;;;;;;;;OAQG;cACa,iBAAiB,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAOvF;;;;;;OAMG;IACH,SAAS,CAAC,WAAW,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,GAAG,KAAK;CAG9D"}

package/dist/src/services/ApiKeyService.d.ts

@@ -0,0 +1,205 @@
+/**
+ * API Key Service
+ *
+ * Handles all API key management operations including creating, listing,
+ * updating, and revoking user-managed API keys with role-based permissions.
+ *
+ * API keys enable delegation of specific permissions to third-party services
+ * or automated systems without sharing full account access.
+ *
+ * @category Services
+ * @since 5.6.0
+ */
+import { HttpClient } from '../utils/http';
+import { BaseService } from './BaseService';
+import type { JwtAuth } from '../auth/JwtAuth';
+import { CreateApiKeyOptions, UpdateApiKeyOptions, ListApiKeysOptions, CreateApiKeyResponse, ApiKeyData, ApiKeyListResponse } from '../types/api-key.dto';
+/**
+ * API Key Service Class
+ *
+ * Provides methods for managing user API keys:
+ * - Create new API keys with role-based permissions
+ * - List all API keys (paginated)
+ * - Get single API key details
+ * - Update API key metadata and permissions
+ * - Revoke (soft delete) API keys
+ *
+ * **CRITICAL**: Raw API keys are ONLY returned on creation and cannot be
+ * retrieved again. Store them securely immediately after creation.
+ *
+ * All endpoints require JWT authentication - only the key owner can manage
+ * their API keys.
+ *
+ * @example
+ * ```typescript
+ * const apiKeyService = new ApiKeyService(httpClient, jwtAuth, true);
+ *
+ * // Create a moderator key for specific tokens
+ * const result = await apiKeyService.create({
+ *   role: 'MODERATOR',
+ *   description: 'Chat moderation bot',
+ *   tokenNames: ['mytoken', 'othertoken']
+ * });
+ * console.log('SAVE THIS KEY:', result.rawKey); // Only shown once!
+ *
+ * // List all keys
+ * const keys = await apiKeyService.findAll({ page: 1, limit: 20 });
+ *
+ * // Revoke a key
+ * await apiKeyService.revoke(keyId);
+ * ```
+ */
+export declare class ApiKeyService extends BaseService {
+    constructor(http: HttpClient, jwtAuth?: JwtAuth, debugMode?: boolean);
+    /**
+     * Extract data from API response wrapper.
+     * @throws Error if response indicates failure or has no data
+     */
+    private extractData;
+    /**
+     * Validate API key ID parameter.
+     * @throws ValidationError if ID is not a positive integer
+     */
+    private validateApiKeyId;
+    /**
+     * Create a new API key
+     *
+     * **CRITICAL**: The `rawKey` in the response is ONLY shown once!
+     * Store it securely immediately - it cannot be retrieved again.
+     *
+     * @param options - API key creation options
+     * @returns Created API key with raw key (shown only once)
+     * @throws ValidationError if options are invalid
+     * @throws ConfigurationError if JWT auth is not configured
+     *
+     * @example
+     * ```typescript
+     * // Create a moderator key for specific tokens
+     * const result = await apiKeyService.create({
+     *   role: 'MODERATOR',
+     *   description: 'Twitch chat bot integration',
+     *   delegateAllTokens: false,
+     *   tokenNames: ['mytoken', 'othertoken'],
+     *   expiresAt: '2025-12-31T23:59:59Z'
+     * });
+     *
+     * // CRITICAL: Save this immediately!
+     * console.log('API Key:', result.rawKey);
+     * // Format: glp_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+     * ```
+     */
+    create(options: CreateApiKeyOptions): Promise<CreateApiKeyResponse>;
+    /**
+     * List all API keys for the authenticated user
+     *
+     * Returns paginated list of API keys. Raw keys are never included in
+     * list responses.
+     *
+     * @param options - Optional pagination options
+     * @returns Paginated list of API keys
+     * @throws ConfigurationError if JWT auth is not configured
+     *
+     * @example
+     * ```typescript
+     * // Get first page
+     * const page1 = await apiKeyService.findAll();
+     *
+     * // Get specific page with custom limit
+     * const page2 = await apiKeyService.findAll({ page: 2, limit: 10 });
+     *
+     * // Iterate through all keys
+     * for (const key of page2.apiKeys) {
+     *   console.log(`${key.keyPrefix} - ${key.role} - ${key.description}`);
+     * }
+     * ```
+     */
+    findAll(options?: ListApiKeysOptions): Promise<ApiKeyListResponse>;
+    /**
+     * Get a single API key by ID
+     *
+     * Returns the API key metadata. Raw key is never included.
+     *
+     * @param id - API key ID
+     * @returns API key data
+     * @throws ValidationError if ID is invalid
+     * @throws ConfigurationError if JWT auth is not configured
+     * @throws Error if API key not found (404)
+     *
+     * @example
+     * ```typescript
+     * const key = await apiKeyService.findOne(123);
+     * console.log(`Key ${key.keyPrefix}: ${key.role}`);
+     * console.log(`Last used: ${key.lastUsedAt || 'Never'}`);
+     * console.log(`Expires: ${key.expiresAt || 'Never'}`);
+     * ```
+     */
+    findOne(id: number): Promise<ApiKeyData>;
+    /**
+     * Update an API key's metadata and permissions
+     *
+     * Cannot change the key itself, only metadata and permissions.
+     * At least one field must be provided.
+     *
+     * @param id - API key ID
+     * @param options - Fields to update
+     * @returns Updated API key data
+     * @throws ValidationError if ID or options are invalid
+     * @throws ConfigurationError if JWT auth is not configured
+     * @throws Error if API key not found (404)
+     *
+     * @example
+     * ```typescript
+     * // Update description
+     * await apiKeyService.update(123, {
+     *   description: 'Updated description'
+     * });
+     *
+     * // Upgrade role and extend expiration
+     * await apiKeyService.update(123, {
+     *   role: 'MANAGER',
+     *   expiresAt: '2026-12-31T23:59:59Z'
+     * });
+     *
+     * // Delegate all tokens
+     * await apiKeyService.update(123, {
+     *   delegateAllTokens: true
+     * });
+     * ```
+     */
+    update(id: number, options: UpdateApiKeyOptions): Promise<ApiKeyData>;
+    /**
+     * Revoke an API key
+     *
+     * This performs a soft delete - the key becomes immediately unusable
+     * but is retained for audit purposes.
+     *
+     * @param id - API key ID to revoke
+     * @throws ValidationError if ID is invalid
+     * @throws ConfigurationError if JWT auth is not configured
+     * @throws Error if API key not found (404)
+     *
+     * @example
+     * ```typescript
+     * // Revoke a key
+     * await apiKeyService.revoke(123);
+     * console.log('API key revoked');
+     *
+     * // Key is now unusable
+     * // Attempts to use it will fail with 401 Unauthorized
+     * ```
+     */
+    revoke(id: number): Promise<void>;
+    /**
+     * Get all valid API key roles
+     *
+     * @returns Array of valid role strings
+     *
+     * @example
+     * ```typescript
+     * const roles = apiKeyService.getRoles();
+     * // ['MODERATOR', 'TECHNICAL_PRODUCER', 'MANAGER', 'OWNER']
+     * ```
+     */
+    getRoles(): string[];
+}
+//# sourceMappingURL=ApiKeyService.d.ts.map

package/dist/src/services/ApiKeyService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApiKeyService.d.ts","sourceRoot":"","sources":["../../../src/services/ApiKeyService.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAO3C,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EACL,mBAAmB,EACnB,mBAAmB,EACnB,kBAAkB,EAClB,oBAAoB,EACpB,UAAU,EACV,kBAAkB,EAKnB,MAAM,sBAAsB,CAAC;AAE9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,qBAAa,aAAc,SAAQ,WAAW;gBAChC,IAAI,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,OAAO,EAAE,SAAS,GAAE,OAAe;IAI3E;;;OAGG;IACH,OAAO,CAAC,WAAW;IAwBnB;;;OAGG;IACH,OAAO,CAAC,gBAAgB;IAQxB;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACG,MAAM,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,oBAAoB,CAAC;IAsCzE;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACG,OAAO,CAAC,OAAO,GAAE,kBAAuB,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAuC5E;;;;;;;;;;;;;;;;;;OAkBG;IACG,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC;IAc9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACG,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,UAAU,CAAC;IAqC3E;;;;;;;;;;;;;;;;;;;;OAoBG;IACG,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAevC;;;;;;;;;;OAUG;IACH,QAAQ,IAAI,MAAM,EAAE;CAGrB"}