@gala-chain/launchpad-sdk 5.0.4-beta.6 → 5.0.4-beta.60

package/dist/services/GalaChainTransferService.d.ts

@@ -0,0 +1,205 @@
+/**
+ * GalaChain Transfer Service
+ *
+ * Service responsible for token transfer and burn operations on GalaChain.
+ * Extracted from GalaChainService for single responsibility.
+ *
+ * Features:
+ * - GALA transfers with EIP-712 signatures
+ * - Generic token transfers (launchpad and standard tokens)
+ * - Token burning (irreversible)
+ * - Token class key resolution
+ *
+ * @example
+ * ```typescript
+ * const transferService = new GalaChainTransferService(http, wallet, tokenResolver, debug);
+ *
+ * // Transfer GALA
+ * const txId = await transferService.transferGala({
+ *   recipientAddress: 'eth|1234567890abcdef1234567890abcdef12345678',
+ *   amount: '1'
+ * });
+ *
+ * // Transfer launchpad token
+ * const txId = await transferService.transferToken({
+ *   to: 'eth|9876543210fedcba9876543210fedcba98765432',
+ *   tokenName: 'tinyevil',
+ *   amount: '100000000'
+ * });
+ *
+ * // Burn tokens (IRREVERSIBLE)
+ * const result = await transferService.burnTokens({
+ *   tokens: [{ tokenName: 'anime', amount: '100' }]
+ * });
+ * ```
+ *
+ * @category Services
+ * @since 5.15.0
+ */
+import type { Wallet } from 'ethers';
+import type { BurnTokensData, BurnTokensResult } from '../types/burn.dto';
+import type { TokenClassKey } from '../types/common';
+import type { TransferGalaData, TransferTokenData } from '../types/transfer.dto';
+import type { HttpClient } from '../utils/http';
+import { BaseService } from './BaseService';
+import type { TokenResolverService } from './TokenResolverService';
+/**
+ * GalaChain Transfer Service
+ *
+ * Handles all token transfer and burn operations on GalaChain.
+ */
+export declare class GalaChainTransferService extends BaseService {
+    private readonly wallet;
+    private readonly tokenResolver;
+    private readonly signatureHelper;
+    /**
+     * Initialize GalaChain Transfer Service
+     *
+     * @param http - HTTP client configured for GalaChain gateway
+     * @param wallet - Ethers wallet for signing transactions (optional for read-only operations)
+     * @param tokenResolver - Token resolver service for vault address resolution
+     * @param debug - Enable debug logging (default: false)
+     */
+    constructor(http: HttpClient, wallet: Wallet | undefined, tokenResolver: TokenResolverService, debug?: boolean);
+    /**
+     * Transfer GALA tokens between wallets
+     *
+     * Creates and signs a TransferToken transaction for GALA using EIP-712
+     * signatures and submits it to the GalaChain gateway.
+     *
+     * @param data - Transfer data including recipient and amount
+     * @returns Promise<string> Transaction ID from successful transfer
+     *
+     * @example
+     * ```typescript
+     * const transactionId = await transferService.transferGala({
+     *   recipientAddress: 'eth|1234567890abcdef1234567890abcdef12345678',
+     *   amount: '1' // 1 GALA
+     * });
+     *
+     * console.log('GALA transfer successful:', transactionId);
+     * ```
+     *
+     * @throws {TransferError} When validation fails or transfer is rejected
+     */
+    transferGala(data: TransferGalaData): Promise<string>;
+    /**
+     * Transfer launchpad tokens between wallets
+     *
+     * Creates and signs a TransferToken transaction for launchpad tokens using
+     * EIP-712 signatures and submits it to the GalaChain gateway.
+     *
+     * @param data - Transfer data including recipient, token name, and amount
+     * @returns Promise<string> Transaction ID from successful transfer
+     *
+     * @example
+     * ```typescript
+     * const transactionId = await transferService.transferToken({
+     *   to: 'eth|9876543210fedcba9876543210fedcba98765432',
+     *   tokenName: 'tinyevil',
+     *   amount: '100000000'
+     * });
+     *
+     * console.log('Token transfer successful:', transactionId);
+     * ```
+     *
+     * @throws {TransferError} When validation fails or transfer is rejected
+     */
+    transferToken(data: TransferTokenData): Promise<string>;
+    /**
+     * Resolve token class key from token name
+     *
+     * Public method to resolve a token name to its tokenClassKey for caching or optimization patterns.
+     * Uses the same resolution logic as transferToken internally.
+     *
+     * @param tokenName - Token name to resolve (e.g., 'unicorn', 'tinyevil')
+     * @returns Promise<TokenClassKey> The resolved token class key object
+     *
+     * @example
+     * ```typescript
+     * const tokenClassKey = await transferService.resolveTokenClassKey('unicorn');
+     * // Returns: { collection: "Token", category: "Unit", type: "UNI", additionalKey: "eth:..." }
+     *
+     * // Can be cached and used later for direct transfers
+     * await transferService.transferToken({
+     *   to: 'eth|...',
+     *   tokenId: tokenClassKey, // Direct, no lookup
+     *   amount: '1'
+     * });
+     * ```
+     *
+     * @throws {TransferError} When token name cannot be resolved
+     */
+    resolveTokenClassKey(tokenName: string): Promise<TokenClassKey>;
+    /**
+     * Permanently burn tokens on GalaChain
+     *
+     * WARNING: THIS OPERATION IS IRREVERSIBLE
+     * Burned tokens cannot be recovered or recreated.
+     * This reduces the total supply of the token.
+     *
+     * Supports batch burning of multiple token types in a single transaction.
+     *
+     * @param data - Burn data containing tokens array with amounts
+     * @returns Result with transaction ID and burned token details
+     * @throws {BurnError} When validation fails or burn operation is rejected
+     *
+     * @example
+     * ```typescript
+     * // Burn a single token type
+     * const result = await transferService.burnTokens({
+     *   tokens: [{ tokenName: 'anime', amount: '100' }]
+     * });
+     *
+     * // Burn multiple token types in one transaction
+     * const result = await transferService.burnTokens({
+     *   tokens: [
+     *     { tokenName: 'anime', amount: '50' },
+     *     { tokenName: 'doge', amount: '25' }
+     *   ]
+     * });
+     * ```
+     */
+    burnTokens(data: BurnTokensData): Promise<BurnTokensResult>;
+    /**
+     * Validate GALA transfer data
+     */
+    private validateTransferGalaData;
+    /**
+     * Validate token transfer data
+     */
+    private validateTransferTokenData;
+    /**
+     * Validate burn tokens data
+     */
+    private validateBurnTokensData;
+    /**
+     * Resolve token name to tokenInstance object for transfers
+     * Uses TokenResolverService to get vault address, then parses it to extract tokenInstance components
+     */
+    private resolveTokenInstance;
+    /**
+     * Extract transaction ID from transfer response
+     * Handles both GalaChain format ({ Status: 1, Data: [...] }) and legacy format ({ transactionId: "..." })
+     *
+     * @param response Transfer response from GalaChain
+     * @param transferType Type of transfer for success message ("gala" or "token")
+     * @returns Transaction ID string
+     * @throws TransferError if transaction ID cannot be extracted
+     * @private
+     */
+    private extractTransactionIdFromResponse;
+    /**
+     * Extract burn result from GalaChain response
+     */
+    private extractBurnResult;
+    /**
+     * Handle transfer/lock/unlock errors with proper typing and context
+     */
+    private handleTransferError;
+    /**
+     * Handle burn operation errors
+     */
+    private handleBurnError;
+}
+//# sourceMappingURL=GalaChainTransferService.d.ts.map

package/dist/services/GalaChainTransferService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GalaChainTransferService.d.ts","sourceRoot":"","sources":["../../src/services/GalaChainTransferService.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAKrC,OAAO,KAAK,EACV,cAAc,EACd,gBAAgB,EACuB,MAAM,mBAAmB,CAAC;AAMnE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAKrD,OAAO,KAAK,EAEsB,gBAAgB,EAChD,iBAAiB,EAAC,MAAM,uBAAuB,CAAC;AAWlD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAOhD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AA2BnE;;;;GAIG;AACH,qBAAa,wBAAyB,SAAQ,WAAW;IAarD,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,aAAa;IAbhC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAA8B;IAE9D;;;;;;;OAOG;gBAED,IAAI,EAAE,UAAU,EACC,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,aAAa,EAAE,oBAAoB,EACpD,KAAK,GAAE,OAAe;IAUxB;;;;;;;;;;;;;;;;;;;;OAoBG;IACG,YAAY,CAAC,IAAI,EAAE,gBAAgB,GAAG,OAAO,CAAC,MAAM,CAAC;IA8D3D;;;;;;;;;;;;;;;;;;;;;OAqBG;IACG,aAAa,CAAC,IAAI,EAAE,iBAAiB,GAAG,OAAO,CAAC,MAAM,CAAC;IAgG7D;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACG,oBAAoB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IA8BrE;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACG,UAAU,CAAC,IAAI,EAAE,cAAc,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAmGjE;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAuBhC;;OAEG;IACH,OAAO,CAAC,yBAAyB;IAkDjC;;OAEG;IACH,OAAO,CAAC,sBAAsB;IA6C9B;;;OAGG;YACW,oBAAoB;IA0DlC;;;;;;;;;OASG;IACH,OAAO,CAAC,gCAAgC;IA+CxC;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAsCzB;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAoE3B;;OAEG;IACH,OAAO,CAAC,eAAe;CA0CxB"}

package/dist/services/HolderService.d.ts

@@ -0,0 +1,181 @@
+/**
+ * Holder Service
+ *
+ * Provides methods for querying real-time holder data, ranks, and balances.
+ *
+ * @category Services
+ * @since 7.1.0
+ */
+import type { HolderRankInfo, TopHoldersData, UserHoldingData } from '../types/holder.types';
+import type { HttpClient } from '../utils/http';
+import { BaseService } from './BaseService';
+/**
+ * Options for fetching holder queries
+ */
+export interface GetHolderOptions {
+    /** Token name (required) */
+    tokenName: string;
+    /** Optional user address to get specific user's holding data */
+    userAddress?: string;
+    /** Optional limit for top holders query (default: 10) */
+    limit?: number;
+}
+/**
+ * Holder Service Class
+ *
+ * Provides methods for querying holder information, ranks, and real-time holdings data.
+ *
+ * @category Services
+ * @since 7.1.0
+ *
+ * @example Query a specific user's holding
+ * ```typescript
+ * const holderService = new HolderService(httpClient);
+ *
+ * const userHolding = await holderService.getUserHolding('anime', 'eth|0x123...');
+ * console.log(`User rank: ${userHolding.rank}`);
+ * console.log(`Balance: ${userHolding.quantity}`);
+ * console.log(`Percentage: ${userHolding.percentage}%`);
+ * ```
+ *
+ * @example Get top holders
+ * ```typescript
+ * const topHolders = await holderService.getTopHolders('GDOG', 20);
+ * console.log(`Top holders: ${topHolders.holders.length}`);
+ * topHolders.holders.forEach((h, i) => {
+ *   console.log(`#${i + 1}: ${h.quantity} tokens`);
+ * });
+ * ```
+ *
+ * @example Get holder count
+ * ```typescript
+ * const count = await holderService.getHolderCount('anime');
+ * console.log(`Total holders: ${count}`);
+ * ```
+ */
+export declare class HolderService extends BaseService {
+    /**
+     * Creates a HolderService instance
+     *
+     * @param http Configured HttpClient with authentication
+     * @param debugMode Enable debug logging (default: false)
+     *
+     * @example
+     * ```typescript
+     * const httpClient = new HttpClient(config);
+     * const holderService = new HolderService(httpClient, true);
+     * ```
+     */
+    constructor(http: HttpClient, debugMode?: boolean);
+    /**
+     * Get a specific user's holding data for a token
+     *
+     * Fetches detailed holder information including rank, balance, tier, and percentage
+     * of total supply. Returns null fields if the user is not a holder.
+     *
+     * @param tokenName Token name to query (required)
+     * @param userAddress User wallet address (required)
+     * @returns Promise resolving to user's holding data
+     * @throws {ValidationError} If token name or user address is invalid
+     * @throws {ValidationError} If API response is invalid
+     *
+     * @category Holder Operations
+     * @since 7.1.0
+     *
+     * @example
+     * ```typescript
+     * const holding = await holderService.getUserHolding('anime', 'eth|0x123...');
+     *
+     * if (holding.rank !== null) {
+     *   console.log(`Rank: #${holding.rank}`);
+     *   console.log(`Balance: ${holding.quantity} tokens`);
+     *   console.log(`Percentage: ${holding.percentage}%`);
+     * } else {
+     *   console.log('User is not a holder');
+     * }
+     * ```
+     */
+    getUserHolding(tokenName: string, userAddress: string): Promise<UserHoldingData>;
+    /**
+     * Get top holders for a token
+     *
+     * Fetches the top N holders by balance. Defaults to top 10 for performance.
+     *
+     * @param tokenName Token name to query (required)
+     * @param limit Maximum number of holders to return (default: 10, max: 100)
+     * @returns Promise resolving to top holders data
+     * @throws {ValidationError} If token name is invalid
+     * @throws {ValidationError} If limit is out of valid range
+     * @throws {ValidationError} If API response is invalid
+     *
+     * @category Holder Operations
+     * @since 7.1.0
+     *
+     * @example Get top 20 holders
+     * ```typescript
+     * const result = await holderService.getTopHolders('GDOG', 20);
+     *
+     * result.holders.forEach((holder, index) => {
+     *   console.log(`#${index + 1}: ${holder.quantity} tokens`);
+     * });
+     *
+     * console.log(`Total holders: ${result.holderCount}`);
+     * ```
+     *
+     * @example Get default top 10
+     * ```typescript
+     * const result = await holderService.getTopHolders('anime');
+     * console.log(`Top 10 holders fetched`);
+     * ```
+     */
+    getTopHolders(tokenName: string, limit?: number): Promise<TopHoldersData>;
+    /**
+     * Get the total holder count for a token
+     *
+     * Efficiently fetches just the count of unique holders without full holder list.
+     *
+     * @param tokenName Token name to query (required)
+     * @returns Promise resolving to holder count
+     * @throws {ValidationError} If token name is invalid
+     * @throws {ValidationError} If API response is invalid
+     *
+     * @category Holder Operations
+     * @since 7.1.0
+     *
+     * @example
+     * ```typescript
+     * const count = await holderService.getHolderCount('anime');
+     * console.log(`Total holders: ${count}`);
+     * ```
+     */
+    getHolderCount(tokenName: string): Promise<number>;
+    /**
+     * Get a user's holder rank for a token
+     *
+     * Returns the user's rank (1 = largest holder) and balance information.
+     * Returns null rank if the user is not a holder.
+     *
+     * @param tokenName Token name to query (required)
+     * @param userAddress User wallet address (required)
+     * @returns Promise resolving to holder rank info
+     * @throws {ValidationError} If parameters are invalid
+     * @throws {ValidationError} If API response is invalid
+     *
+     * @category Holder Operations
+     * @since 7.1.0
+     *
+     * @example
+     * ```typescript
+     * const rankInfo = await holderService.getHolderRank('anime', 'eth|0x123...');
+     *
+     * if (rankInfo.rank !== null) {
+     *   console.log(`User rank: #${rankInfo.rank}`);
+     *   console.log(`Balance: ${rankInfo.balance}`);
+     * } else {
+     *   console.log('User is not a holder');
+     * }
+     * ```
+     */
+    getHolderRank(tokenName: string, userAddress: string): Promise<HolderRankInfo | null>;
+}
+//# sourceMappingURL=HolderService.d.ts.map

package/dist/services/HolderService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HolderService.d.ts","sourceRoot":"","sources":["../../src/services/HolderService.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EACV,cAAc,EACd,cAAc,EACd,eAAe,EAChB,MAAM,uBAAuB,CAAC;AAG/B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAGhD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAG5C;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,4BAA4B;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,gEAAgE;IAChE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,yDAAyD;IACzD,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AA8BD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,qBAAa,aAAc,SAAQ,WAAW;IAC5C;;;;;;;;;;;OAWG;gBACS,IAAI,EAAE,UAAU,EAAE,SAAS,GAAE,OAAe;IAIxD;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACG,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC;IA0BtF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACG,aAAa,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,GAAE,MAAW,GAAG,OAAO,CAAC,cAAc,CAAC;IAqCnF;;;;;;;;;;;;;;;;;;OAkBG;IACG,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAWxD;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACG,aAAa,CAAC,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC;CAe5F"}

package/dist/services/ImageService.d.ts

@@ -0,0 +1,173 @@
+/**
+ * Image Service
+ *
+ * Handles all image upload operations for tokens and profiles.
+ *
+ * @category Services
+ * @since 3.6.0
+ */
+import type { JwtAuth } from '../auth/JwtAuth';
+import type { UploadImageByTokenNameOptions } from '../types/options.dto';
+import type { HttpClient } from '../utils/http';
+import { BaseService } from './BaseService';
+/**
+ * Image Service Class
+ *
+ * Provides methods for:
+ * - Uploading token images with validation
+ * - Multi-environment support (Node.js and browser)
+ * - Image format and size validation
+ * - Automatic signature generation for secure uploads
+ *
+ * @category Services
+ * @since 3.6.0
+ *
+ * @example Basic token image upload
+ * ```typescript
+ * const imageService = new ImageService(httpClient);
+ *
+ * // Upload token image
+ * const imageUrl = await imageService.uploadImageByTokenName({
+ *   tokenName: 'mytoken',
+ *   options: { file: imageFile, tokenName: 'mytoken' }
+ * });
+ * console.log('Image uploaded:', imageUrl);
+ * ```
+ *
+ * @example Browser file upload with validation
+ * ```typescript
+ * const fileInput = document.querySelector('#image-upload') as HTMLInputElement;
+ * const file = fileInput.files?.[0];
+ *
+ * if (file) {
+ *   // Validate file size before upload
+ *   if (file.size > 5 * 1024 * 1024) {
+ *     console.error('File too large (max 5MB)');
+ *     return;
+ *   }
+ *
+ *   const imageUrl = await imageService.uploadImageByTokenName({
+ *     tokenName: 'anime',
+ *     options: { file, tokenName: 'anime' }
+ *   });
+ * }
+ * ```
+ *
+ * @example Node.js buffer upload
+ * ```typescript
+ * import * as fs from 'fs';
+ *
+ * const imageBuffer = fs.readFileSync('./token-logo.png');
+ * const imageUrl = await imageService.uploadImageByTokenName({
+ *   tokenName: 'GDOG',
+ *   options: { file: imageBuffer, tokenName: 'GDOG' }
+ * });
+ * ```
+ */
+export declare class ImageService extends BaseService {
+    /**
+     * Creates an ImageService instance
+     *
+     * @param http Configured HttpClient with authentication
+     * @param jwtAuth Optional JWT auth manager for authenticated uploads
+     * @param debugMode Enable debug logging (default: false)
+     *
+     * @example
+     * ```typescript
+     * const httpClient = new HttpClient(config);
+     * const imageService = new ImageService(httpClient, jwtAuth, true);
+     * ```
+     */
+    constructor(http: HttpClient, jwtAuth?: JwtAuth, debugMode?: boolean);
+    /**
+     * Uploads an image for a token pool
+     *
+     * Uploads a token image that will be used for branding and display purposes.
+     * Supports both browser File objects and Node.js Buffer objects for maximum
+     * compatibility across environments.
+     *
+     * File Requirements:
+     * - Format: PNG, JPG, JPEG, WebP
+     * - Size: Maximum 5MB
+     * - Dimensions: Recommended 512x512px or higher
+     * - Aspect ratio: Square (1:1) recommended
+     *
+     * Security:
+     * - **Requires JWT authentication** - call sdk.login() before using this method
+     * - Server-side validation
+     *
+     * @param options Upload configuration object
+     * @param options.file Image file as File object (browser) or Buffer (Node.js)
+     * @param options.tokenName Token name for the image (must be valid token name format)
+     * @returns Promise resolving to image URL string (empty string if no URL returned)
+     * @throws {ValidationError} If token name format is invalid
+     * @throws {FileValidationError} If file doesn't meet requirements (size, format)
+     * @throws {ConfigurationError} If JWT auth is not configured (call sdk.login() first)
+     * @throws {ConfigurationError} If FormData not supported in environment
+     * @throws {ApiError} If upload fails due to network or server issues
+     *
+     * @category Image Operations
+     * @since 3.6.0
+     *
+     * @example Browser file upload with preview
+     * ```typescript
+     * const fileInput = document.querySelector('#image-upload') as HTMLInputElement;
+     * const file = fileInput.files?.[0];
+     *
+     * if (file) {
+     *   // Show preview
+     *   const preview = URL.createObjectURL(file);
+     *   imgElement.src = preview;
+     *
+     *   // Upload
+     *   const imageUrl = await service.uploadImageByTokenName({
+     *     file,
+     *     tokenName: 'anime'
+     *   });
+     *   console.log('Uploaded:', imageUrl);
+     * }
+     * ```
+     *
+     * @example Node.js buffer upload with validation
+     * ```typescript
+     * import * as fs from 'fs';
+     *
+     * const imageBuffer = fs.readFileSync('./token-logo.png');
+     * const stats = fs.statSync('./token-logo.png');
+     *
+     * // Validate size before upload
+     * if (stats.size > 5 * 1024 * 1024) {
+     *   throw new Error('Image too large (max 5MB)');
+     * }
+     *
+     * const imageUrl = await service.uploadImageByTokenName({
+     *   file: imageBuffer,
+     *   tokenName: 'GDOG'
+     * });
+     * console.log('Image URL:', imageUrl);
+     * ```
+     *
+     * @example Error handling
+     * ```typescript
+     * import { getErrorMessage } from '../utils/error-utils';
+     *
+     * try {
+     *   const imageUrl = await service.uploadImageByTokenName({
+     *     file: imageFile,
+     *     tokenName: 'GUSDC'
+     *   });
+     *   console.log('Success:', imageUrl);
+     * } catch (error: unknown) {
+     *   if (error instanceof ValidationError) {
+     *     console.error('Invalid token name:', error.message);
+     *   } else if (getErrorMessage(error).includes('FormData')) {
+     *     console.error('Environment does not support file uploads');
+     *   } else {
+     *     console.error('Upload failed:', getErrorMessage(error));
+     *   }
+     * }
+     * ```
+     */
+    uploadImageByTokenName(options: UploadImageByTokenNameOptions): Promise<string>;
+}
+//# sourceMappingURL=ImageService.d.ts.map

package/dist/services/ImageService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ImageService.d.ts","sourceRoot":"","sources":["../../src/services/ImageService.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAK/C,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,sBAAsB,CAAC;AAM1E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAIhD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAG5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,qBAAa,YAAa,SAAQ,WAAW;IAC3C;;;;;;;;;;;;OAYG;gBACS,IAAI,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,OAAO,EAAE,SAAS,GAAE,OAAe;IAI3E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAwFG;IACG,sBAAsB,CAC1B,OAAO,EAAE,6BAA6B,GACrC,OAAO,CAAC,MAAM,CAAC;CA+CnB"}