@gala-chain/launchpad-sdk 6.0.0 → 7.0.0-beta.1

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

@@ -1,227 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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

@@ -1,150 +0,0 @@
-/**
- * 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 type { OffsetPaginationFetchResult } from '../utils/auto-pagination.js';
-import type { HttpClient } from '../utils/http.js';
-import { Logger } from '../utils/Logger.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

@@ -1 +0,0 @@
-{"version":3,"file":"AbstractTokenFetchService.d.ts","sourceRoot":"","sources":["../../../src/services/AbstractTokenFetchService.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,6BAA6B,CAAC;AAI/E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAG5C,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

@@ -1,211 +0,0 @@
-/**
- * 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 type { JwtAuth } from '../auth/JwtAuth';
-import type { ApiKeyData, ApiKeyListResponse, CreateApiKeyOptions, CreateApiKeyResponse, ListApiKeysOptions, UpdateApiKeyOptions } from '../types/api-key.dto';
-import type { HttpClient } from '../utils/http';
-import { BaseService } from './BaseService';
-/**
- * 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 cursor-based pagination options
-     * @returns Paginated list of API keys
-     * @throws ConfigurationError if JWT auth is not configured
-     * @updated 8.1.0 - Migrated to cursor-based pagination
-     *
-     * @example
-     * ```typescript
-     * // Get first page
-     * const page1 = await apiKeyService.findAll({ pageSize: 20 });
-     *
-     * // Get next page using cursor
-     * if (page1.pageInfo.hasNextPage) {
-     *   const page2 = await apiKeyService.findAll({
-     *     pageSize: 20,
-     *     cursor: page1.pageInfo.nextCursor
-     *   });
-     * }
-     *
-     * // Iterate through all keys
-     * for (const key of page1.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

@@ -1 +0,0 @@
-{"version":3,"file":"ApiKeyService.d.ts","sourceRoot":"","sources":["../../../src/services/ApiKeyService.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAE/C,OAAO,KAAK,EACV,UAAU,EACV,kBAAkB,EAAG,mBAAmB,EACxC,oBAAoB,EACpB,kBAAkB,EAClB,mBAAmB,EAAC,MAAM,sBAAsB,CAAC;AAUnD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEhD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAG5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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;IAiCnB;;;OAGG;IACH,OAAO,CAAC,gBAAgB;IAQxB;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACG,MAAM,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,oBAAoB,CAAC;IAyCzE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACG,OAAO,CAAC,OAAO,GAAE,kBAAuB,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAqB5E;;;;;;;;;;;;;;;;;;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;IAwC3E;;;;;;;;;;;;;;;;;;;;OAoBG;IACG,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAevC;;;;;;;;;;OAUG;IACH,QAAQ,IAAI,MAAM,EAAE;CAGrB"}