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

package/dist/src/LaunchpadSDK.d.ts

@@ -1,24 +1,39 @@
 import { Wallet } from 'ethers';
 import { SDKConfig, AddressFormat, TokenClassKey, TokenId } from './types/common';
+import { StreamEventCallbacks } from './services/StreamWebSocketService';
 import { EthereumWalletBalanceResult, SolanaWalletBalanceResult, ExternalChainBalance, EstimateBridgeFeeParams, BridgeFeeEstimate, BridgeOutParams, BridgeInParams, BridgeTransaction, BridgeStatus, BridgeToken, EthereumTransactionStatus, SolanaTransactionStatus } from './bridge/types/bridge.dto';
 import type { BridgeableNetwork, FetchBridgeableTokensOptions, FetchBridgeableTokensResult, IsTokenBridgeableOptions, IsTokenBridgeableResult } from './bridge/types/bridgeable-token.dto';
 import type { WrappableToken, FetchWrappableTokensOptions, FetchWrappableTokensResult, IsTokenWrappableResult, WrapTokenOptions, UnwrapTokenOptions, WrapUnwrapResult, WrapUnwrapFeeEstimate, WrapUnwrapStatusResult } from './types/wrappable-token.dto';
+import type { StreamInfo, StartStreamResult, ResetStreamKeyResult, FetchRecordingsOptions, RecordingsResult, RecordingDownloadResult, AddSimulcastTargetOptions, SimulcastTargetsResult, AddSimulcastTargetResult, GlobalStreamingStatus, StreamSubscribedEvent, GetStreamRoleOptions, StreamRoleResponse, GetTokenAccessOptions, TokenAccessResult } from './types/streaming.dto';
+import type { ChatStatusResponse, GlobalChatStatus, GetEngagementStatsOptions, EngagementStatsResult } from './types/stream-chat.dto';
+import type { CreateBanOptions, CreateBanResult, RemoveBanOptions, RemoveBanResult, ListBansOptions, BanListResult, GetBanStatusOptions, BanStatusResult, GetActiveUsersOptions, ActiveUsersResult } from './types/ban.dto';
+import type { BanTokenOptions, BanTokenResult, UnbanTokenOptions, UnbanTokenResult, ListTokenBansOptions, TokenBanListResult, GetTokenBanOptions, TokenBanStatusResult } from './types/token-ban.dto';
+import type { CreateApiKeyOptions, UpdateApiKeyOptions, ListApiKeysOptions, CreateApiKeyResponse, ApiKeyData, ApiKeyListResponse } from './types/api-key.dto';
+import type { CreateModeratorInviteOptions, ClaimModeratorInviteOptions, ListModeratorInvitesOptions, GetModeratedTokensOptions, UpdateInviteRoleOptions, CreateModeratorInviteResult, ClaimModeratorInviteResult, ModeratorInviteListResult, ModeratedTokensResult, UpdateInviteRoleResult, PublicInviteInfo } from './types/moderator.dto';
+import type { LoginResponse, SessionInfo, RefreshResponse } from './types/session-auth.dto';
+import type { CreateFlagOptions, CreateFlagResult, ListFlagsOptions, ListGlobalFlagsOptions, FlagListResult, DismissFlagOptions, DismissFlagResult, ActionFlagOptions, ActionFlagResult } from './types/content-flag.dto';
+import type { CreateOverseerInviteOptions, ListOverseerInvitesOptions, ListOverseersOptions, OverseerInviteWithUrl, PublicOverseerInviteInfo, PaginatedOverseerInvites, PaginatedOverseers, OverseerStatusResponse, OverseerSummaryResponse, ListUsersOptions, UsersListResponse, UserSummaryResponse } from './types/overseer.dto';
+import type { AddContentReactionOptions, RemoveContentReactionOptions, AddContentReactionResult, RemoveContentReactionResult } from './types/content-reactions.dto';
+import type { GetCommentsOptions, CreateCommentOptions, UpdateCommentOptions, CommentsResult, CreateCommentResult, UpdateCommentResult, DeleteCommentResult } from './types/comments.dto';
+import type { GetChatMessagesOptions, CreateChatMessageOptions, UpdateChatMessageOptions, GetChatMessagesResult, CreateChatMessageResult, UpdateChatMessageResult } from './types/chat-messages.dto';
+import type { GetTradesOptions, TradesQueryResult } from './types/trades-query.dto';
 import { PoolDetailsData } from './types/trade.dto';
-import { LaunchTokenData, TokenSpotPrice, FetchPoolsOptions, PoolsResult, GalaChainTokenDetails, PoolData, TokenClassWithSupply, DexSeason, LeaderboardResult, DexAggregatedVolumeSummary } from './types/launchpad.dto';
-import { UpdateProfileData, UploadProfileImageOptions, FetchTokenBalanceOptions, LockedBalanceResult, AvailableBalanceResult, ReferralUrlResult, FetchReferralsOptions, ReferralsResult, AllReferralsResult, FetchReferralsSummaryOptions, ReferralsSummaryResult, RegisterAccountOptions, RegisterAccountResult } from './types/user.dto';
+import { LaunchTokenData, TokenSpotPrice, FetchPoolsOptions, PoolsResult, GalaChainTokenDetails, PoolData, TokenClassWithSupply, DexSeason, LeaderboardResult, DexAggregatedVolumeSummary, UpdateSocialLinksDto, UpdateSocialLinksResponse } from './types/launchpad.dto';
+import { UpdateProfileData, UploadProfileImageOptions, FetchTokenBalanceOptions, LockedBalanceResult, AvailableBalanceResult, ReferralUrlResult, FetchReferralsOptions, ReferralsResult, AllReferralsResult, FetchReferralsSummaryOptions, ReferralsSummaryResult, RegisterAccountOptions, RegisterAccountResult, GetManagedTokensOptions, ManagedTokensResult } from './types/user.dto';
 import { TransferGalaData, TransferTokenData } from './types/transfer.dto';
 import { LockTokensData, LockTokensResult, UnlockTokensData, UnlockTokensResult } from './types/lock.dto';
 import { BurnTokensData, BurnTokensResult } from './types/burn.dto';
 import { TokenLaunchResult, TradeResult } from './types/result.types';
 import { WebSocketError, WebSocketTimeoutError, TransactionFailedError } from './utils/websocket-errors';
 export { WebSocketError, WebSocketTimeoutError, TransactionFailedError, };
-import { FetchVolumeDataOptions, FetchTradesOptions, CalculateBuyAmountOptions, CalculateSellAmountOptions, CalculateBuyAmountLocalOptions, CalculateSellAmountLocalOptions, BuyTokenOptions, SellTokenOptions, UploadImageByTokenNameOptions, FetchTokensHeldOptions, FetchTokensCreatedOptions, GraduateTokenOptions, FetchLaunchpadTokenSpotPriceOptions, FetchTokenSpotPriceParams, CalculateBuyAmountForGraduationOptions } from './types/options.dto';
+import { FetchVolumeDataOptions, FetchTradesOptions, CalculateBuyAmountOptions, CalculateSellAmountOptions, CalculateBuyAmountLocalOptions, CalculateSellAmountLocalOptions, BuyTokenOptions, SellTokenOptions, UploadImageByTokenNameOptions, FetchTokensHeldOptions, FetchTokensCreatedOptions, GraduateTokenOptions, FetchTokenSpotPriceParams, CalculateBuyAmountForGraduationOptions } from './types/options.dto';
 import { FetchPriceHistoryOptions, PriceHistoryResult } from './types/priceHistory.dto';
 import { FetchDexPoolsOptions, DexPoolsResult, DexPoolData } from './types/dex-pool.dto';
 import { GSwapPosition, PoolPriceData, GetLiquidityPositionsOptions, GetLiquidityPositionsResult, RemoveLiquidityArgs, AddLiquidityByPriceArgs, AddLiquidityByTicksArgs, CollectFeesArgs, DexToken, FetchAvailableDexTokensOptions, AvailableDexTokensResult } from './types/gswap.dto';
 import type { FetchCompositePoolDataOptions, CompositePoolDataResult, CalculateDexPoolQuoteOptions, DexPoolQuoteResult } from './types/composite-pool.dto';
 import type { SubscribeSwapOptions, SwapMonitorConfig, CleanupFunction, SwapEventCallback } from './types/swap-monitor.dto';
 import type { LiquidityChangedCallback, LiquidityCleanupFunction, SubscribeLiquidityOptions } from './types/liquidity-monitor.dto';
+import { AvailableRolesResponse } from './types/streaming.dto';
 /**
  * Configuration for initializing the Launchpad SDK
  *
@@ -166,6 +181,33 @@ export interface LaunchpadSDKConfig extends SDKConfig {
      * ```
      */
     solanaRpcUrl?: string;
+    /**
+     * Optional Stream WebSocket URL for live streaming features.
+     *
+     * This is a SEPARATE endpoint from bundleBaseUrl, dedicated to streaming operations.
+     * Required for real-time stream status, viewer count, and chat functionality.
+     *
+     * @since 5.1.0
+     * @example
+     * ```typescript
+     * const sdk = new LaunchpadSDK({
+     *   wallet,
+     *   streamWebSocketUrl: 'wss://stream.gala.com'
+     * });
+     * ```
+     */
+    streamWebSocketUrl?: string;
+    /**
+     * Optional Admin API key for stream management operations.
+     *
+     * Required for admin-only operations:
+     * - Disabling/enabling streams per token
+     * - Disabling/enabling streaming globally
+     * - Disabling/enabling chat per token or globally
+     *
+     * @since 5.1.0
+     */
+    streamAdminApiKey?: string;
 }
 /**
  * Main Launchpad SDK class providing access to all Gala Launchpad functionality
@@ -239,6 +281,8 @@ export declare class LaunchpadSDK {
     private wallet;
     private readonly galaChainAddressOverride;
     private readonly auth;
+    private readonly jwtAuth;
+    private readonly sessionAuth;
     private readonly http;
     private readonly galaChainHttp;
     private readonly galaChainPublicAxios;
@@ -268,6 +312,20 @@ export declare class LaunchpadSDK {
     private _wrappableTokenService?;
     private _wrapService?;
     private _galaConnectClient?;
+    private _streamingService;
+    private _streamChatService;
+    private _streamWebSocketService;
+    private _streamingEventService;
+    private _banService;
+    private _tokenBanService;
+    private _apiKeyService;
+    private _moderatorService;
+    private _flagService;
+    private _overseerService;
+    private _commentService;
+    private _contentReactionService;
+    private _commentsService;
+    private _chatMessagesService;
     private readonly launchpadAPI;
     constructor(config: LaunchpadSDKConfig);
     /**
@@ -336,7 +394,7 @@ export declare class LaunchpadSDK {
      * const backendAddr = sdk.getAddress();
      *
      * // Verify they represent the same address
-     * const ethHex = ethAddr.replace('0x', '');
+     * const ethHex = stripHexPrefix(ethAddr);
      * const backendHex = backendAddr.replace('eth|', '');
      * console.log('Same address:', ethHex.toLowerCase() === backendHex.toLowerCase());
      * ```
@@ -595,7 +653,7 @@ export declare class LaunchpadSDK {
      * @example Basic pool fetching
      * ```typescript
      * const result = await sdk.fetchPools({ type: 'recent', page: 1, limit: 20 });
-     * console.log(`Fetched ${result.pools.length} pools`);
+     * console.log(`Fetched ${result.items.length} pools`);
      * console.log(`Total pools: ${result.total}`);
      * ```
      *
@@ -660,14 +718,14 @@ export declare class LaunchpadSDK {
      * @example Fetch all recent pools
      * ```typescript
      * const all = await sdk.fetchAllPools({ type: 'recent' });
-     * console.log(`Fetched ${all.pools.length} total pools`);
+     * console.log(`Fetched ${all.items.length} total pools`);
      * console.log(`Total available: ${all.total}`);
      * ```
      *
      * @example Fetch all pools matching search
      * ```typescript
      * const dragons = await sdk.fetchAllPools({ search: 'dragon' });
-     * console.log(`Found ${dragons.pools.length} dragon tokens`);
+     * console.log(`Found ${dragons.items.length} dragon tokens`);
      * ```
      *
      * @example Cache warming demonstration
@@ -677,11 +735,11 @@ export declare class LaunchpadSDK {
      *
      * // Check cache statistics
      * const cacheInfo = sdk.getCacheInfo();
-     * console.log(`Cached ${cacheInfo.totalTokens} tokens from ${all.pools.length} pools`);
+     * console.log(`Cached ${cacheInfo.totalTokens} tokens from ${all.items.length} pools`);
      *
      * // All subsequent calculations are instant (no network calls)
      * const calculations = await Promise.all(
-     *   all.pools.slice(0, 10).map(pool =>
+     *   all.items.slice(0, 10).map(pool =>
      *     sdk.calculateBuyAmountLocal({
      *       tokenName: pool.tokenName,
      *       amount: '100',
@@ -725,7 +783,7 @@ export declare class LaunchpadSDK {
      * console.log(`Found ${result.total} total pools`);
      * console.log(`Showing page ${result.page} of ${result.totalPages}`);
      *
-     * result.pools.forEach(pool => {
+     * result.items.forEach(pool => {
      *   console.log(`${pool.poolName}: $${pool.tvl.toFixed(2)} TVL`);
      * });
      * ```
@@ -737,7 +795,7 @@ export declare class LaunchpadSDK {
      *   limit: 20
      * });
      *
-     * console.log(`Found ${galaPools.pools.length} GALA trading pairs`);
+     * console.log(`Found ${galaPools.items.length} GALA trading pairs`);
      * ```
      *
      * @example Get pools sorted by TVL (default)
@@ -774,7 +832,7 @@ export declare class LaunchpadSDK {
      * console.log(`Total pools: ${allPools.total}`);
      *
      * // Find top GALA pools
-     * const galaPools = allPools.pools
+     * const galaPools = allPools.items
      *   .filter(p => p.poolName.includes('GALA'))
      *   .slice(0, 10);
      *
@@ -788,7 +846,7 @@ export declare class LaunchpadSDK {
      * const allPools = await sdk.fetchAllDexPools();
      *
      * // Find pools by token
-     * const guscPairs = allPools.pools.filter(p =>
+     * const guscPairs = allPools.items.filter(p =>
      *   p.poolName.includes('GUSDC')
      * );
      *
@@ -992,6 +1050,33 @@ export declare class LaunchpadSDK {
      * ```
      */
     fetchTokenDistribution(tokenName: string): Promise<import("./types/launchpad.dto").TokenDistributionResult>;
+    /**
+     * Fetch a user's holder context for a specific token
+     *
+     * Retrieves holder tier, quantity, percentage, and creator status for a user
+     * on a specific token. Used for user cards in comments/chat to show
+     * token-specific holder information.
+     *
+     * @category Token Information
+     * @param tokenName - Token name to check holdings for (e.g., 'anime', 'mytoken')
+     * @param userAddress - User wallet address to lookup
+     * @returns Promise with user holder context including tier, quantity, percentage, isCreator
+     * @throws {ValidationError} If tokenName or userAddress is invalid or empty
+     * @throws {NetworkError} If API request fails
+     * @since 3.7.0
+     *
+     * @example Get holder context for user card
+     * ```typescript
+     * const context = await sdk.fetchUserHolderContext('anime', '0x1234...');
+     * if (context.holderTier) {
+     *   console.log(`User is a ${context.holderTier.tierName} holding ${context.percentage}%`);
+     * }
+     * if (context.isCreator) {
+     *   console.log('User created this token');
+     * }
+     * ```
+     */
+    fetchUserHolderContext(tokenName: string, userAddress: string): Promise<import("./types/launchpad.dto").UserHolderContext>;
     /**
      * Fetch token achievement badges and metadata
      *
@@ -1065,37 +1150,6 @@ export declare class LaunchpadSDK {
      * @throws Error if DEX Backend API client not configured
      */
     fetchGalaPrice(): Promise<TokenSpotPrice>;
-    /**
-     * Calculate spot price for a launchpad token in USD
-     *
-     * @deprecated Use {@link fetchTokenPrice} with `{ tokenName }` parameter instead.
-     * This method will be removed in SDK v4.0.0.
-     *
-     * Intelligently determines the best price source based on token graduation status:
-     * - **Active Pools** (bonding curve ongoing): Uses bonding curve calculation
-     * - **Graduated Tokens** (DEX trading): Uses DEX spot price endpoint for real market price
-     *
-     * Performance optimization: Provide currentSupply to avoid fetching pool details twice.
-     *
-     * @param tokenNameOrOptions Token name string OR FetchLaunchpadTokenSpotPriceOptions object
-     * @returns Promise<TokenSpotPrice> Spot price with symbol and USD price
-     *
-     * @deprecated Use {@link fetchTokenPrice} instead - provides smart routing for both launchpad and DEX tokens
-     *
-     * @example Use the new smart router instead
-     * ```typescript
-     * // ❌ OLD (deprecated)
-     * const price = await sdk.fetchLaunchpadTokenSpotPrice('galadog');
-     *
-     * // ✅ NEW (recommended)
-     * const price = await sdk.fetchTokenPrice({ tokenName: 'galadog' });
-     * ```
-     *
-     * @throws Error if token not found
-     * @throws Error if price calculation fails
-     * @throws Error if GALA price unavailable
-     */
-    fetchLaunchpadTokenSpotPrice(tokenNameOrOptions: string | FetchLaunchpadTokenSpotPriceOptions): Promise<TokenSpotPrice>;
     /**
      * Fetch comprehensive token details from DEX API platform
      *
@@ -1666,6 +1720,171 @@ export declare class LaunchpadSDK {
      * @internal This is a private helper method for wrap/unwrap operations
      */
     private getWrapService;
+    /**
+     * Get or create the StreamingService instance.
+     *
+     * Lazily initializes the StreamingService on first use.
+     * The service handles REST API calls for stream management,
+     * recordings, and simulcast targets.
+     *
+     * @returns Configured StreamingService instance
+     *
+     * @internal This is a private helper method for streaming operations
+     * @since 5.1.0
+     */
+    private getStreamingService;
+    /**
+     * Get or create the StreamChatService instance.
+     *
+     * Lazily initializes the StreamChatService on first use.
+     * The service handles REST API calls for chat operations
+     * including messages, status, and admin controls.
+     *
+     * @returns Configured StreamChatService instance
+     *
+     * @internal This is a private helper method for chat operations
+     * @since 5.1.0
+     */
+    private getStreamChatService;
+    /**
+     * Get or create the BanService instance.
+     *
+     * Lazily initializes the BanService on first use.
+     * The service handles REST API calls for ban operations
+     * including creating/removing bans, listing bans, and active users.
+     *
+     * @returns Configured BanService instance
+     *
+     * @internal This is a private helper method for ban operations
+     * @since 5.5.0
+     */
+    private getBanService;
+    /**
+     * Get or create the TokenBanService instance.
+     *
+     * Lazily initializes the TokenBanService on first use.
+     * The service handles REST API calls for platform-wide token ban operations
+     * (overseer-only).
+     *
+     * @returns Configured TokenBanService instance
+     *
+     * @internal This is a private helper method for token ban operations
+     * @since 6.x.0
+     */
+    private getTokenBanService;
+    /**
+     * Get or create the ApiKeyService instance.
+     *
+     * Lazily initializes the ApiKeyService on first use.
+     * The service handles REST API calls for API key CRUD operations.
+     *
+     * @returns Configured ApiKeyService instance
+     *
+     * @internal This is a private helper method for API key operations
+     * @since 5.6.0
+     */
+    private getApiKeyService;
+    /**
+     * Get or create the ModeratorService instance.
+     *
+     * Lazily initializes the ModeratorService on first use.
+     * The service handles REST API calls for moderator invite operations
+     * including creating/claiming invites, listing invites, and managing access.
+     *
+     * @returns Configured ModeratorService instance
+     *
+     * @internal This is a private helper method for moderator invite operations
+     * @since 5.7.0
+     */
+    private getModeratorService;
+    /**
+     * Get or create the ContentFlagService instance.
+     *
+     * Lazily initializes the ContentFlagService on first use.
+     * The service handles REST API calls for content flag operations
+     * including creating flags, listing flags, and taking action on flags.
+     *
+     * @returns Configured ContentFlagService instance
+     *
+     * @internal This is a private helper method for flag operations
+     * @since 5.8.0
+     */
+    private getFlagService;
+    /**
+     * Get or create the OverseerService instance.
+     *
+     * Lazily initializes the OverseerService on first use.
+     * The service handles REST API calls for overseer operations
+     * including creating/claiming invites and managing overseers.
+     *
+     * @returns Configured OverseerService instance
+     *
+     * @internal This is a private helper method for overseer operations
+     * @since 5.9.0
+     */
+    private getOverseerService;
+    /**
+     * Get or create the CommentService instance.
+     *
+     * Lazily initializes the CommentService on first use.
+     * Comments support both public (fetch) and authenticated (post, delete) operations.
+     *
+     * @internal
+     */
+    private getCommentService;
+    /**
+     * Get or create the ContentReactionService instance.
+     *
+     * Lazily initializes the ContentReactionService on first use.
+     * Content reactions are persistent reactions (heart, fire, laugh, wow, thumbs_up)
+     * on chat messages and comments.
+     *
+     * @internal
+     */
+    private getContentReactionService;
+    /**
+     * Get or create the CommentsService instance.
+     *
+     * Lazily initializes the CommentsService on first use.
+     * Uses v1 comments endpoints for full CRUD operations.
+     *
+     * @returns Configured CommentsService instance
+     * @internal
+     * @since 6.2.0
+     */
+    private getCommentsService;
+    /**
+     * Get or create the ChatMessagesService instance.
+     *
+     * Lazily initializes the ChatMessagesService on first use.
+     * Uses v1 chat-messages endpoints for full CRUD operations.
+     *
+     * @returns Configured ChatMessagesService instance
+     * @internal
+     * @since 6.2.0
+     */
+    private getChatMessagesService;
+    /**
+     * Get or create the StreamWebSocketService instance.
+     *
+     * Lazily initializes the StreamWebSocketService on first use.
+     * The service handles real-time WebSocket connections for
+     * stream status, viewer counts, and chat messages.
+     *
+     * @returns Configured StreamWebSocketService instance
+     * @throws Error if streamWebSocketUrl is not configured
+     *
+     * @internal This is a private helper method for real-time streaming operations
+     * @since 5.1.0
+     */
+    private getStreamWebSocketService;
+    /**
+     * Get the streaming event service
+     *
+     * @internal
+     * @since 5.12.0
+     */
+    private getStreamingEventService;
     /**
      * Fetch a single ERC-20 token balance on Ethereum.
      *
@@ -2368,192 +2587,2983 @@ export declare class LaunchpadSDK {
      */
     getWrapStatus(transactionId: string): Promise<WrapUnwrapStatusResult>;
     /**
-     * Estimate bridge fees for a cross-chain transfer.
+     * Login with wallet signature to get JWT token.
      *
-     * Calculates the expected fees for bridging tokens from GalaChain to an
-     * external chain (Ethereum or Solana).
+     * This authenticates the user with the backend by:
+     * 1. Generating a message with timestamp: "Sign in to Launchpad t:{timestamp}"
+     * 2. Signing the message with the configured wallet
+     * 3. Sending the signature to the backend for verification
+     * 4. Storing the returned JWT token for authenticated requests
      *
-     * @param params - Fee estimation parameters
-     * @returns Promise resolving to fee estimate with breakdown
+     * Required before calling JWT-protected endpoints:
+     * - `startStream()`, `stopStream()`, `resetStreamKey()`, `getRecordingDownload()`, `deleteRecording()`
+     * - `addSimulcastTarget()`, `removeSimulcastTarget()`
+     * - `sendChatMessage()` (REST API)
+     *
+     * @returns Login response with accessToken and expiration
      * @throws Error if wallet is not configured
-     * @throws Error if token is not bridgeable to the destination chain
+     * @throws Error if signature fails
      *
-     * @since 4.0.16
-     * @category Bridge
+     * @since 5.2.0
+     * @category Authentication
      *
-     * @example Estimate fee for bridging GALA to Ethereum
+     * @example Basic login
      * ```typescript
-     * const fee = await sdk.estimateBridgeFee({
-     *   tokenId: 'GALA|Unit|none|none',
-     *   destinationChain: 'Ethereum',
-     *   amount: '100',
-     * });
-     * console.log(`Fee: ${fee.totalFee} GALA`);
+     * const { accessToken, expiresIn, address } = await sdk.login();
+     * console.log(`Logged in as ${address}`);
+     * console.log(`Token expires in ${expiresIn}s`);
+     * ```
+     *
+     * @example Login before streaming
+     * ```typescript
+     * // Authenticate first
+     * await sdk.login();
+     *
+     * // Now streaming methods work
+     * const stream = await sdk.startStream('mytoken');
      * ```
      */
-    estimateBridgeFee(params: EstimateBridgeFeeParams): Promise<BridgeFeeEstimate>;
+    login(): Promise<LoginResponse>;
     /**
-     * Bridge tokens from GalaChain to an external chain.
+     * Refresh the current JWT token.
      *
-     * Initiates a cross-chain transfer from GalaChain to Ethereum or Solana.
-     * The transfer will lock tokens on GalaChain and mint wrapped tokens on
-     * the destination chain.
+     * Use this to get a new token before the current one expires.
+     * The token is automatically refreshed during requests if
+     * it will expire within 5 minutes.
      *
-     * @param params - Bridge out parameters
-     * @returns Promise resolving to transaction details
-     * @throws Error if wallet is not configured
-     * @throws Error if token is not bridgeable to the destination chain
-     * @throws Error if recipient address is invalid
+     * @returns Refresh response with new accessToken
+     * @throws Error if not authenticated (call login() first)
      *
-     * @since 4.0.16
-     * @category Bridge
+     * @since 5.2.0
+     * @category Authentication
      *
-     * @example Bridge GALA to Ethereum
+     * @example Manual token refresh
      * ```typescript
-     * const result = await sdk.bridgeOut({
-     *   tokenId: 'GALA|Unit|none|none',
-     *   amount: '100',
-     *   destinationChain: 'Ethereum',
-     *   recipientAddress: '0x1234...abcd',
-     * });
-     * console.log(`Transaction: ${result.transactionHash}`);
+     * if (sdk.shouldRefreshToken()) {
+     *   const { accessToken, expiresIn } = await sdk.refreshToken();
+     *   console.log(`Token refreshed, expires in ${expiresIn}s`);
+     * }
      * ```
      */
-    bridgeOut(params: BridgeOutParams): Promise<BridgeTransaction>;
+    refreshToken(): Promise<RefreshResponse>;
     /**
-     * Bridge tokens from an external chain to GalaChain.
-     *
-     * Initiates a cross-chain transfer from Ethereum or Solana to GalaChain.
-     * The transfer will burn wrapped tokens on the source chain and unlock
-     * tokens on GalaChain.
+     * Logout and clear the JWT token.
      *
-     * @param params - Bridge in parameters
-     * @returns Promise resolving to transaction details
-     * @throws Error if wallet is not configured
-     * @throws Error if token is not bridgeable from the source chain
+     * This clears the client-side token. Future calls to JWT-protected
+     * endpoints will fail until login() is called again.
      *
-     * @since 4.0.16
-     * @category Bridge
+     * @since 5.2.0
+     * @category Authentication
      *
-     * @example Bridge GALA from Ethereum to GalaChain
+     * @example Clean logout
      * ```typescript
-     * const result = await sdk.bridgeIn({
-     *   tokenId: 'GALA|Unit|none|none',
-     *   amount: '100',
-     *   sourceChain: 'Ethereum',
-     * });
-     * console.log(`Transaction: ${result.transactionHash}`);
+     * // ... do work ...
+     * sdk.logout();
+     * console.log('Logged out');
      * ```
      */
-    bridgeIn(params: BridgeInParams): Promise<BridgeTransaction>;
+    logout(): void;
     /**
-     * Get the status of a bridge transaction.
+     * Check if user is authenticated with valid JWT.
      *
-     * Checks the current status of a cross-chain bridge transaction.
+     * Returns true if:
+     * - A JWT token exists
+     * - The token has not expired
      *
-     * @param transactionHash - Transaction hash to check
-     * @param chainHint - Optional chain hint for faster lookup
-     * @returns Promise resolving to bridge status
+     * @returns true if authenticated with non-expired token
      *
-     * @since 4.0.16
-     * @category Bridge
+     * @since 5.2.0
+     * @category Authentication
      *
-     * @example Check bridge status
+     * @example Check authentication status
      * ```typescript
-     * const status = await sdk.getBridgeStatus(
-     *   '0x1234...abcd',
-     *   'Ethereum'
-     * );
-     * console.log(`Status: ${status.status}`);
+     * if (!sdk.isAuthenticated()) {
+     *   await sdk.login();
+     * }
+     * // Now proceed with authenticated operations
      * ```
      */
-    getBridgeStatus(transactionHash: string, chainHint?: 'Ethereum' | 'Solana'): Promise<BridgeStatus>;
+    isAuthenticated(): boolean;
     /**
-     * Get list of tokens supported for bridging.
+     * Check if token should be refreshed.
      *
-     * Returns the static list of tokens that can be bridged between
-     * GalaChain and external chains.
+     * Returns true if token exists and will expire within the threshold.
+     * Default threshold is 5 minutes.
      *
-     * @returns Promise resolving to supported bridge tokens
+     * @param thresholdMs - Custom threshold in milliseconds (default: 5 minutes)
+     * @returns true if refresh is recommended
      *
-     * @since 4.0.16
-     * @category Bridge
+     * @since 5.2.0
+     * @category Authentication
      *
-     * @example Get supported tokens
+     * @example Check before long operation
      * ```typescript
-     * const tokens = await sdk.getSupportedBridgeTokens();
-     * tokens.tokens.forEach(t => {
-     *   console.log(`${t.symbol}: ${t.supportedChains.join(', ')}`);
-     * });
+     * // Ensure token won't expire during operation
+     * if (sdk.shouldRefreshToken(10 * 60 * 1000)) { // 10 minutes
+     *   await sdk.refreshToken();
+     * }
+     * await performLongOperation();
      * ```
      */
-    getSupportedBridgeTokens(): Promise<{
-        tokens: BridgeToken[];
-        totalCount: number;
-        supportedChains: string[];
-    }>;
+    shouldRefreshToken(thresholdMs?: number): boolean;
     /**
-     * Fetch token balance from GalaChain (published tokens) or DEX API (launchpad tokens)
+     * Get current session information from the backend.
      *
-     * This method queries either the GalaChain gateway directly for published tokens
-     * or the DEX API for launchpad tokens, providing reliable results.
+     * Returns session details including:
+     * - Authenticated address
+     * - Token issued time
+     * - Token expiration time
      *
-     * @param options Token balance options with flexible token identification
-     * @returns Promise<TokenBalanceResult | null>
+     * @returns Session info with address and timestamps
+     * @throws Error if not authenticated
      *
-     * @example
+     * @since 5.2.0
+     * @category Authentication
+     *
+     * @example View session details
      * ```typescript
-     * // Using string format
-     * const galaBalance = await sdk.fetchTokenBalance({
-     *   address: sdk.getAddress(),
-     *   tokenId: "GALA|Unit|none|none"
-     * });
+     * const session = await sdk.getSession();
+     * console.log(`Logged in as: ${session.address}`);
+     * console.log(`Session expires: ${session.expiresAt}`);
+     * ```
+     */
+    getSession(): Promise<SessionInfo>;
+    /**
+     * Get the current JWT access token.
      *
-     * // Using TokenClassKey object
-     * const tokenClass = await sdk.resolveTokenClassKey('unicorn');
-     * const unicornBalance = await sdk.fetchTokenBalance({
-     *   address: sdk.getAddress(),
-     *   tokenClassKey: tokenClass
-     * });
+     * Returns the raw token string for use in custom requests
+     * or debugging. Returns null if not authenticated.
      *
-     * // Using TokenInstanceKey object
-     * const unicornBalance2 = await sdk.fetchTokenBalance({
-     *   address: sdk.getAddress(),
-     *   tokenId: {
-     *     collection: "Token",
-     *     category: "Unit",
-     *     type: "UNI",
-     *     additionalKey: "eth:9401b171307bE656f00F9e18DF756643FD3a91dE",
-     *     instance: "0"
-     *   }
-     * });
+     * @returns Access token string, or null if not authenticated
      *
-     * // Using token name for convenience
-     * const unicornBalance3 = await sdk.fetchTokenBalance({
-     *   address: sdk.getAddress(),
-     *   tokenName: "unicorn"
-     * });
+     * @since 5.2.0
+     * @category Authentication
+     *
+     * @example Use token in custom request
+     * ```typescript
+     * const token = sdk.getAccessToken();
+     * if (token) {
+     *   const headers = { 'Authorization': `Bearer ${token}` };
+     *   // Use headers in custom fetch call
+     * }
      * ```
      */
-    fetchTokenBalance(options: FetchTokenBalanceOptions): Promise<import("./types/user.dto").TokenBalanceResult | {
-        quantity: unknown;
-        collection: {};
-        category: string;
-        tokenId: string;
-        symbol: string;
-        name: string;
-    } | null>;
+    getAccessToken(): string | null;
     /**
-     * Fetch only locked balance for a token
+     * Ensure we have a valid token, refreshing if necessary.
      *
-     * Returns focused information about locked tokens including lock details.
-     * Requires tokenId (not tokenName) as lock details are only available from GalaChain.
+     * Call this before making authenticated requests to ensure
+     * the token won't expire mid-request. Will:
+     * - Throw if not authenticated at all
+     * - Re-login if token is expired
+     * - Refresh if token expires within threshold
+     * - Return current token if still valid
      *
-     * @param options Balance query options (must include tokenId, not tokenName)
-     * @returns Promise<LockedBalanceResult | null> Locked balance details or null if no balance
-     * @throws Error if tokenName is provided (lock details require tokenId)
+     * @param thresholdMs - Refresh threshold in milliseconds (default: 5 minutes)
+     * @returns Current access token
+     * @throws Error if not authenticated and can't refresh
      *
-     * @example
+     * @since 5.2.0
+     * @category Authentication
+     *
+     * @example Before critical operation
+     * ```typescript
+     * const token = await sdk.ensureValidToken();
+     * // Token is guaranteed valid for at least 5 more minutes
+     * await criticalStreamingOperation();
+     * ```
+     */
+    ensureValidToken(thresholdMs?: number): Promise<string>;
+    /**
+     * Start a live stream for a token.
+     *
+     * Creates a new stream session and returns streaming credentials.
+     * The stream key can be used with OBS or other RTMP-compatible software.
+     *
+     * @param tokenName - Token name (lowercase)
+     * @returns Promise resolving to stream credentials
+     * @throws Error if wallet is not configured
+     * @throws Error if streaming is disabled for this token
+     *
+     * @since 5.1.0
+     * @category Streaming
+     *
+     * @example Start streaming for a token
+     * ```typescript
+     * const stream = await sdk.startStream('mytoken');
+     * console.log(`RTMP URL: ${stream.rtmpUrl}`);
+     * console.log(`Stream Key: ${stream.streamKey}`);
+     * console.log(`Playback URL: ${stream.playbackUrl}`);
+     * ```
+     */
+    startStream(tokenName: string): Promise<StartStreamResult>;
+    /**
+     * Stop an active stream for a token.
+     *
+     * Immediately ends the current broadcast and sets the stream to IDLE.
+     * Requires JWT authentication (stream creator only).
+     * The stream can be restarted by calling startStream() again.
+     *
+     * Unlike disableStream() which is an admin operation that prevents streaming,
+     * stopStream() is for stream owners to end their current broadcast.
+     *
+     * @param tokenName - Token name (lowercase)
+     * @throws ValidationError if token name is invalid
+     * @throws Error if user is not authorized (not stream owner)
+     * @throws Error if stream is not currently active
+     *
+     * @since 5.3.0
+     * @category Streaming
+     *
+     * @see https://www.mux.com/docs/api-reference/video/live-streams/signal-live-stream-complete
+     *
+     * @example Stop an active stream
+     * ```typescript
+     * await sdk.stopStream('mytoken');
+     * console.log('Stream stopped successfully');
+     * ```
+     */
+    stopStream(tokenName: string): Promise<void>;
+    /**
+     * Get stream information for a token.
+     *
+     * Returns current stream status, playback information, and metadata.
+     * Does not require authentication for public stream information.
+     *
+     * @param tokenName - Token name (lowercase)
+     * @returns Promise resolving to stream information
+     *
+     * @since 5.1.0
+     * @category Streaming
+     *
+     * @example Check stream status
+     * ```typescript
+     * const info = await sdk.getStreamInfo('mytoken');
+     * if (info.isLive) {
+     *   console.log(`Stream is live! Viewers: ${info.viewerCount}`);
+     *   console.log(`Watch at: https://player.example.com/${info.playbackId}`);
+     * }
+     * ```
+     */
+    getStreamInfo(tokenName: string): Promise<StreamInfo>;
+    /**
+     * Disable streaming for a specific token (Admin only).
+     *
+     * Prevents new streams from being started for this token.
+     * Existing active streams will continue until they end.
+     *
+     * @param tokenName - Token name (lowercase)
+     * @returns Promise resolving when disabled
+     * @throws Error if admin API key is not configured
+     *
+     * @since 5.1.0
+     * @category Streaming
+     * @admin Requires streamAdminApiKey configuration
+     */
+    disableStream(tokenName: string): Promise<{
+        enabled: boolean;
+        tokenName: string;
+    }>;
+    /**
+     * Enable streaming for a specific token (Admin only).
+     *
+     * Re-enables streaming capability for a previously disabled token.
+     *
+     * @param tokenName - Token name (lowercase)
+     * @returns Promise resolving when enabled
+     * @throws Error if admin API key is not configured
+     *
+     * @since 5.1.0
+     * @category Streaming
+     * @admin Requires streamAdminApiKey configuration
+     */
+    enableStream(tokenName: string): Promise<{
+        enabled: boolean;
+        tokenName: string;
+    }>;
+    /**
+     * Reset the stream key for a token.
+     *
+     * Generates a new stream key, invalidating the previous one.
+     * Use this if the stream key has been compromised.
+     *
+     * @param tokenName - Token name (lowercase)
+     * @returns Promise resolving to new stream credentials
+     * @throws Error if wallet is not configured
+     *
+     * @since 5.1.0
+     * @category Streaming
+     *
+     * @example Reset compromised stream key
+     * ```typescript
+     * const newCreds = await sdk.resetStreamKey('mytoken');
+     * console.log(`New Stream Key: ${newCreds.streamKey}`);
+     * console.log(`Reset at: ${newCreds.resetAt}`);
+     * ```
+     */
+    resetStreamKey(tokenName: string): Promise<ResetStreamKeyResult>;
+    /**
+     * Get recordings for a stream.
+     *
+     * Returns list of available recordings from past streams.
+     *
+     * @param tokenName - Token name (lowercase)
+     * @param options - Pagination options
+     * @returns Promise resolving to recordings list
+     *
+     * @since 5.1.0
+     * @category Streaming
+     *
+     * @example List recordings
+     * ```typescript
+     * const { recordings, total } = await sdk.getStreamRecordings({ tokenName: 'mytoken' });
+     * recordings.forEach(rec => {
+     *   console.log(`${rec.createdAt}: ${rec.duration}s - ${rec.status}`);
+     * });
+     * ```
+     */
+    getStreamRecordings(options: FetchRecordingsOptions): Promise<RecordingsResult>;
+    /**
+     * Get download URL for a recording.
+     *
+     * Returns a signed URL for downloading a specific recording.
+     * URLs are typically valid for a limited time.
+     *
+     * @param tokenName - Token name (lowercase)
+     * @param assetId - Recording asset ID
+     * @returns Promise resolving to download URL
+     * @throws Error if wallet is not configured
+     *
+     * @since 5.1.0
+     * @category Streaming
+     *
+     * @example Download a recording
+     * ```typescript
+     * const result = await sdk.getRecordingDownload('mytoken', 'asset-123');
+     * console.log(`Download: ${result.downloadUrl}`);
+     * console.log(`Expires: ${result.expiresAt}`);
+     * ```
+     */
+    getRecordingDownload(tokenName: string, assetId: string): Promise<RecordingDownloadResult>;
+    /**
+     * Delete a recording.
+     *
+     * Permanently removes a recording. This action cannot be undone.
+     *
+     * @param tokenName - Token name (lowercase)
+     * @param assetId - Recording asset ID
+     * @returns Promise resolving when deleted
+     * @throws Error if wallet is not configured
+     *
+     * @since 5.1.0
+     * @category Streaming
+     */
+    deleteRecording(tokenName: string, assetId: string): Promise<void>;
+    /**
+     * Get simulcast targets for a stream.
+     *
+     * Returns list of configured simulcast destinations (YouTube, Twitch, etc.).
+     *
+     * @param tokenName - Token name (lowercase)
+     * @returns Promise resolving to simulcast targets
+     *
+     * @since 5.1.0
+     * @category Streaming
+     *
+     * @example Check simulcast configuration
+     * ```typescript
+     * const { targets } = await sdk.getSimulcastTargets('mytoken');
+     * targets.forEach(t => {
+     *   console.log(`${t.platform}: ${t.status}`);
+     * });
+     * ```
+     */
+    getSimulcastTargets(tokenName: string): Promise<SimulcastTargetsResult>;
+    /**
+     * Add a simulcast target to a stream.
+     *
+     * Configure the stream to rebroadcast to an external platform.
+     *
+     * @param tokenName - Token name (lowercase)
+     * @param options - Simulcast target configuration
+     * @returns Promise resolving to the new target
+     * @throws Error if wallet is not configured
+     *
+     * @since 5.1.0
+     * @category Streaming
+     *
+     * @example Add YouTube simulcast
+     * ```typescript
+     * const target = await sdk.addSimulcastTarget({
+     *   tokenName: 'mytoken',
+     *   platform: 'YOUTUBE',
+     *   streamKey: 'xxxx-xxxx-xxxx-xxxx',
+     *   rtmpUrl: 'rtmp://a.rtmp.youtube.com/live2',
+     * });
+     * console.log(`Added target: ${target.id}`);
+     * ```
+     */
+    addSimulcastTarget(options: AddSimulcastTargetOptions): Promise<AddSimulcastTargetResult>;
+    /**
+     * Remove a simulcast target from a stream.
+     *
+     * Stops rebroadcasting to the specified platform.
+     *
+     * @param tokenName - Token name (lowercase)
+     * @param targetId - Simulcast target ID
+     * @returns Promise resolving when removed
+     * @throws Error if wallet is not configured
+     *
+     * @since 5.1.0
+     * @category Streaming
+     */
+    removeSimulcastTarget(tokenName: string, targetId: string): Promise<void>;
+    /**
+     * Get global streaming status.
+     *
+     * Returns platform-wide streaming status including maintenance windows.
+     *
+     * @returns Promise resolving to global streaming status
+     *
+     * @since 5.1.0
+     * @category Streaming
+     *
+     * @example Check if streaming is available
+     * ```typescript
+     * const status = await sdk.getGlobalStreamingStatus();
+     * if (!status.enabled) {
+     *   console.log(`Streaming disabled: ${status.reason ?? 'maintenance'}`);
+     * }
+     * ```
+     */
+    getGlobalStreamingStatus(): Promise<GlobalStreamingStatus>;
+    /**
+     * Set the next live stream countdown time (v6.x.0+)
+     *
+     * Convenience method that sets a scheduled time for the next live stream.
+     * The frontend can display a countdown timer based on this time.
+     *
+     * @param tokenName Token name (lowercase)
+     * @param nextLiveStreamAt Scheduled stream time (ISO 8601 string, Date, or null to clear)
+     * @returns Updated stream settings
+     * @throws {ValidationError} If token name or date is invalid
+     *
+     * @since 6.x.0
+     * @category Streaming
+     *
+     * @example Set countdown
+     * ```typescript
+     * await sdk.setNextLiveStreamCountdown('mytoken', '2025-01-15T18:00:00Z');
+     * // or
+     * await sdk.setNextLiveStreamCountdown('mytoken', new Date('2025-01-15T18:00:00Z'));
+     * // Clear countdown
+     * await sdk.setNextLiveStreamCountdown('mytoken', null);
+     * ```
+     */
+    setNextLiveStreamCountdown(tokenName: string, nextLiveStreamAt: string | Date | null): Promise<import('./types/streaming.dto').StreamSettings>;
+    /**
+     * Enable or disable streaming globally (Admin only).
+     *
+     * Controls platform-wide streaming capability.
+     *
+     * @param enabled - Whether streaming should be enabled
+     * @returns Promise resolving when updated
+     * @throws Error if admin API key is not configured
+     *
+     * @since 5.1.0
+     * @category Streaming
+     * @admin Requires streamAdminApiKey configuration
+     */
+    setGlobalStreamingEnabled(enabled: boolean): Promise<GlobalStreamingStatus>;
+    /**
+     * Get the authenticated user's role for a token's stream.
+     *
+     * Returns the user's effective role based on:
+     * - Token ownership (OWNER role)
+     * - Claimed moderator invite (MANAGER, TECHNICAL_PRODUCER, or MODERATOR)
+     * - No access (null role)
+     *
+     * This enables the frontend Studio page to detect permissions and show
+     * the appropriate UI based on the user's role.
+     *
+     * **Authentication:** Optional JWT - returns null role if not authenticated.
+     *
+     * @param options - GetStreamRoleOptions with tokenName
+     * @returns Promise resolving to StreamRoleResponse with role, isOwner flag, source, and inviteScope
+     *
+     * @since 5.7.0
+     * @category Streaming
+     *
+     * @example Check stream access
+     * ```typescript
+     * const roleInfo = await sdk.getStreamRole({ tokenName: 'mytoken' });
+     *
+     * if (roleInfo.role === null) {
+     *   console.log('No access to this stream');
+     * } else if (roleInfo.isOwner) {
+     *   console.log('You are the token owner');
+     * } else {
+     *   console.log(`You have ${roleInfo.role} access via ${roleInfo.source}`);
+     * }
+     *
+     * // Use role for permission checks
+     * const canStream = ['OWNER', 'MANAGER', 'TECHNICAL_PRODUCER'].includes(roleInfo.role ?? '');
+     * const canModerate = ['OWNER', 'MANAGER', 'MODERATOR'].includes(roleInfo.role ?? '');
+     * ```
+     */
+    getStreamRole(options: GetStreamRoleOptions): Promise<StreamRoleResponse>;
+    /**
+     * Get all available roles and permissions for token delegation.
+     *
+     * Returns reference data about the role system, including:
+     * - All available roles (OWNER, MANAGER, TECHNICAL_PRODUCER, MODERATOR)
+     * - Role descriptions and hierarchy levels
+     * - Permissions assigned to each role
+     * - Complete list of all available permissions
+     *
+     * This is static reference data - it doesn't change per user or token.
+     *
+     * @returns Promise resolving to available roles and permissions
+     *
+     * @since 5.10.0
+     * @category Streaming
+     *
+     * @example Get available roles
+     * ```typescript
+     * const { roles, permissions } = await sdk.getAvailableRoles();
+     *
+     * // List all roles
+     * roles.forEach(role => {
+     *   console.log(`${role.name} (level ${role.level}): ${role.description}`);
+     *   console.log('  Permissions:', role.permissions.join(', '));
+     * });
+     *
+     * // Build a role selector dropdown
+     * const roleOptions = roles.map(role => ({
+     *   value: role.name,
+     *   label: role.description,
+     *   level: role.level,
+     * }));
+     * ```
+     */
+    getAvailableRoles(): Promise<AvailableRolesResponse>;
+    /**
+     * Check if the authenticated user has Studio access for a token.
+     *
+     * Returns comprehensive access information combining:
+     * - Token ownership check (OWNER role)
+     * - Claimed moderator invite (MANAGER, TECHNICAL_PRODUCER, MODERATOR)
+     * - Platform overseer status (global access)
+     *
+     * This is used by the frontend to determine whether to show the
+     * "Click to Studio" link on the buy-sell page.
+     *
+     * @param options Options with tokenName
+     * @returns Promise resolving to access info with role, permissions, and flags
+     *
+     * @since 5.11.0
+     * @category Streaming
+     *
+     * @example Check Studio access
+     * ```typescript
+     * const access = await sdk.getTokenAccess({ tokenName: 'mytoken' });
+     *
+     * if (!access.hasAccess) {
+     *   console.log('No Studio access for this token');
+     * } else {
+     *   console.log(`Access via: ${access.accessSource}`);
+     *   console.log(`Role: ${access.role}`);
+     *   console.log('Permissions:', access.permissions);
+     *
+     *   if (access.permissions.canStream) {
+     *     console.log('User can start/stop streams');
+     *   }
+     *   if (access.permissions.canModerate) {
+     *     console.log('User can moderate chat');
+     *   }
+     * }
+     * ```
+     */
+    getTokenAccess(options: GetTokenAccessOptions): Promise<TokenAccessResult>;
+    /**
+     * Get chat messages for a stream.
+     *
+     * Returns paginated list of chat messages for a stream.
+     *
+     * @param tokenName - Token name (lowercase)
+     * @param options - Pagination options
+     * @returns Promise resolving to chat messages
+     *
+     * @since 5.1.0
+     * @category Chat
+     *
+     * Get chat status for a stream.
+     *
+     * Returns whether chat is enabled for the stream and the reason if disabled.
+     *
+     * @param tokenName - Token name (lowercase)
+     * @returns Promise resolving to chat status
+     *
+     * @since 5.1.0
+     * @category Chat
+     *
+     * @example Check chat availability
+     * ```typescript
+     * const status = await sdk.getChatStatus('mytoken');
+     * if (!status.enabled) {
+     *   console.log(`Chat disabled: ${status.reason}`);
+     * }
+     * ```
+     */
+    getChatStatus(tokenName: string): Promise<ChatStatusResponse>;
+    /**
+     * Get engagement statistics for a token.
+     *
+     * Returns aggregated engagement metrics including:
+     * - Chat: message count, unique chatters, session start time
+     * - Comments: total count, unique commenters
+     *
+     * Chat stats are scoped to the current/last stream session.
+     * Comment stats are all-time for the token.
+     *
+     * @param options - Token name to fetch stats for
+     * @returns Promise resolving with engagement statistics
+     *
+     * @since 5.10.0
+     * @category Chat
+     *
+     * @example Get engagement stats
+     * ```typescript
+     * const stats = await sdk.getEngagementStats({ tokenName: 'mytoken' });
+     * console.log('Chat messages:', stats.chat.messageCount);
+     * console.log('Unique chatters:', stats.chat.uniqueChatters);
+     * console.log('Total comments:', stats.comments.count);
+     * console.log('Unique commenters:', stats.comments.uniqueCommenters);
+     * ```
+     */
+    getEngagementStats(options: GetEngagementStatsOptions): Promise<EngagementStatsResult>;
+    /**
+     * Disable chat for a specific token.
+     *
+     * Supports dual authentication:
+     * - **Admin (API key)**: Sets ADMIN_DISABLED - owner locked out
+     * - **Owner (JWT)**: Sets DISABLED - owner can re-enable
+     *
+     * @param tokenName - Token name (lowercase)
+     * @returns Promise resolving with enabled status and detailed status
+     * @throws Error if neither admin API key nor JWT is configured
+     *
+     * @since 5.1.0
+     * @since 5.4.0 - Added dual-auth support (Admin API key OR JWT owner)
+     * @category Chat
+     */
+    disableChat(tokenName: string): Promise<{
+        enabled: boolean;
+        tokenName: string;
+        status?: string;
+    }>;
+    /**
+     * Enable chat for a specific token.
+     *
+     * Supports dual authentication:
+     * - **Admin (API key)**: Sets ENABLED - clears lock, owner regains control
+     * - **Owner (JWT)**: Sets ENABLED - fails with 403 if ADMIN_DISABLED
+     *
+     * @param tokenName - Token name (lowercase)
+     * @returns Promise resolving with enabled status and detailed status
+     * @throws Error if neither admin API key nor JWT is configured
+     * @throws Error (403) if owner tries to enable when ADMIN_DISABLED
+     *
+     * @since 5.1.0
+     * @since 5.4.0 - Added dual-auth support (Admin API key OR JWT owner)
+     * @category Chat
+     */
+    enableChat(tokenName: string): Promise<{
+        enabled: boolean;
+        tokenName: string;
+        status?: string;
+    }>;
+    /**
+     * Get global chat status.
+     *
+     * Returns platform-wide chat status.
+     *
+     * @returns Promise resolving to global chat status
+     *
+     * @since 5.1.0
+     * @category Chat
+     */
+    getGlobalChatStatus(): Promise<GlobalChatStatus>;
+    /**
+     * Enable or disable chat globally (Admin only).
+     *
+     * Controls platform-wide chat capability.
+     *
+     * @param enabled - Whether chat should be enabled
+     * @returns Promise resolving when updated
+     * @throws Error if admin API key is not configured
+     *
+     * @since 5.1.0
+     * @category Chat
+     * @admin Requires streamAdminApiKey configuration
+     */
+    setGlobalChatEnabled(enabled: boolean): Promise<GlobalChatStatus>;
+    /**
+     * Get the currently pinned chat message for a token (v6.x.0+)
+     *
+     * Retrieves the pinned message for a token's chat if one exists.
+     *
+     * @param tokenName Token name (lowercase)
+     * @returns Pinned message details or null if no message is pinned
+     * @throws {ValidationError} If token name is invalid
+     *
+     * @since 6.x.0
+     * @category Chat
+     *
+     * @example Get pinned message
+     * ```typescript
+     * const pinned = await sdk.getPinnedChatMessage('mytoken');
+     * if (pinned) {
+     *   console.log('Pinned message:', pinned.content);
+     *   console.log('Pinned by:', pinned.pinnedBy);
+     * }
+     * ```
+     */
+    getPinnedChatMessage(tokenName: string): Promise<import('./types/stream-chat.dto').GetPinnedMessageResult>;
+    /**
+     * Pin a chat message for a token (v6.x.0+)
+     *
+     * Pins a message to the top of the chat for this token.
+     * Requires admin or manager access.
+     *
+     * @param tokenName Token name (lowercase)
+     * @param messageId ID of the message to pin
+     * @returns Pinned message result with confirmation
+     * @throws {ValidationError} If token name or message ID is invalid
+     * @throws {Error} If user is not authorized to pin messages
+     *
+     * @since 6.x.0
+     * @category Chat
+     *
+     * @example Pin a message
+     * ```typescript
+     * const result = await sdk.pinChatMessage('mytoken', 'msg123');
+     * console.log('Message pinned:', result.pinnedMessage.id);
+     * ```
+     */
+    pinChatMessage(tokenName: string, messageId: string): Promise<import('./types/stream-chat.dto').PinMessageResult>;
+    /**
+     * Unpin the currently pinned chat message for a token (v6.x.0+)
+     *
+     * Removes the pinned message from a token's chat.
+     * Requires admin or manager access.
+     *
+     * @param tokenName Token name (lowercase)
+     * @throws {ValidationError} If token name is invalid
+     * @throws {Error} If user is not authorized to unpin messages
+     *
+     * @since 6.x.0
+     * @category Chat
+     *
+     * @example Unpin a message
+     * ```typescript
+     * await sdk.unpinChatMessage('mytoken');
+     * console.log('Message unpinned');
+     * ```
+     */
+    unpinChatMessage(tokenName: string): Promise<import('./types/stream-chat.dto').UnpinMessageResult>;
+    /**
+     * Create a ban for a user on a token.
+     *
+     * Bans a user from participating in chat, comments, and reactions for the
+     * specified token. Can be temporary (with duration) or permanent.
+     *
+     * Supports dual authentication:
+     * - **Admin (API key)**: Can ban any user on any token
+     * - **Owner (JWT)**: Can ban users on their own token
+     *
+     * @param options - Ban creation options
+     * @returns Promise resolving to the created ban
+     * @throws Error if neither admin API key nor JWT is configured
+     *
+     * @since 5.5.0
+     * @category Moderation
+     *
+     * @example Ban a user permanently
+     * ```typescript
+     * const result = await sdk.createBan({
+     *   tokenName: 'mytoken',
+     *   userAddress: 'eth|abc123...',
+     *   reason: 'Spam',
+     * });
+     * console.log(`Banned: ${result.ban.userAddress}`);
+     * ```
+     *
+     * @example Ban a user for 24 hours
+     * ```typescript
+     * const result = await sdk.createBan({
+     *   tokenName: 'mytoken',
+     *   userAddress: 'eth|abc123...',
+     *   reason: 'Warning for inappropriate content',
+     *   durationSeconds: 86400, // 24 hours
+     * });
+     * console.log(`Expires: ${result.ban.expiresAt}`);
+     * ```
+     */
+    createBan(options: CreateBanOptions): Promise<CreateBanResult>;
+    /**
+     * Remove a ban for a user on a token.
+     *
+     * Unbans a user, allowing them to participate in chat, comments, and reactions again.
+     *
+     * Supports dual authentication:
+     * - **Admin (API key)**: Can unban any user on any token
+     * - **Owner (JWT)**: Can unban users on their own token
+     *
+     * @param options - Ban removal options
+     * @returns Promise resolving to removal confirmation
+     * @throws Error if neither admin API key nor JWT is configured
+     * @throws Error (404) if ban not found
+     *
+     * @since 5.5.0
+     * @category Moderation
+     *
+     * @example Unban a user
+     * ```typescript
+     * const result = await sdk.removeBan({
+     *   tokenName: 'mytoken',
+     *   userAddress: 'eth|abc123...',
+     * });
+     * console.log(`Unbanned: ${result.removed}`);
+     * ```
+     */
+    removeBan(options: RemoveBanOptions): Promise<RemoveBanResult>;
+    /**
+     * List all bans for a token.
+     *
+     * Returns a paginated list of banned users with their profile information,
+     * ban reasons, and expiration times.
+     *
+     * Supports dual authentication:
+     * - **Admin (API key)**: Can list bans for any token
+     * - **Owner (JWT)**: Can list bans for their own token
+     *
+     * @param options - List options including pagination and filters
+     * @returns Promise resolving to paginated ban list
+     * @throws Error if neither admin API key nor JWT is configured
+     *
+     * @since 5.5.0
+     * @category Moderation
+     *
+     * @example List all bans
+     * ```typescript
+     * const result = await sdk.listBans({ tokenName: 'mytoken' });
+     * console.log(`Total bans: ${result.meta.total}`);
+     * result.bans.forEach(ban => {
+     *   console.log(`${ban.userAddress}: ${ban.reason}`);
+     * });
+     * ```
+     *
+     * @example Search bans by user
+     * ```typescript
+     * const result = await sdk.listBans({
+     *   tokenName: 'mytoken',
+     *   search: 'alice', // Search by address or name
+     *   page: 1,
+     *   limit: 20,
+     * });
+     * ```
+     */
+    listBans(options: ListBansOptions): Promise<BanListResult>;
+    /**
+     * Get ban status for a specific user on a token.
+     *
+     * Checks if a user is currently banned and returns ban details if so.
+     *
+     * Supports dual authentication:
+     * - **Admin (API key)**: Can check any user on any token
+     * - **Owner (JWT)**: Can check users on their own token
+     *
+     * @param options - Status check options
+     * @returns Promise resolving to ban status
+     * @throws Error if neither admin API key nor JWT is configured
+     *
+     * @since 5.5.0
+     * @category Moderation
+     *
+     * @example Check if user is banned
+     * ```typescript
+     * const status = await sdk.getBanStatus({
+     *   tokenName: 'mytoken',
+     *   userAddress: 'eth|abc123...',
+     * });
+     * if (status.banned) {
+     *   console.log(`Banned for: ${status.ban?.reason}`);
+     *   console.log(`Expires: ${status.ban?.expiresAt ?? 'permanent'}`);
+     * }
+     * ```
+     */
+    getBanStatus(options: GetBanStatusOptions): Promise<BanStatusResult>;
+    /**
+     * Get active users for a token.
+     *
+     * Returns a list of users currently viewing or participating in a stream.
+     * Can filter by viewer type (all viewers or only chat participants).
+     *
+     * Returns up to 1000 users. If more are connected, the `truncated` flag
+     * will be true.
+     *
+     * Supports dual authentication:
+     * - **Admin (API key)**: Can get users for any token
+     * - **Owner (JWT)**: Can get users for their own token
+     *
+     * @param options - Active users options
+     * @returns Promise resolving to active users list
+     * @throws Error if neither admin API key nor JWT is configured
+     *
+     * @since 5.5.0
+     * @category Moderation
+     *
+     * @example Get all viewers
+     * ```typescript
+     * const result = await sdk.getActiveUsers({
+     *   tokenName: 'mytoken',
+     *   type: 'viewers',
+     * });
+     * console.log(`${result.total} viewers online`);
+     * if (result.truncated) {
+     *   console.log('More than 1000 users, list truncated');
+     * }
+     * ```
+     *
+     * @example Search for a specific user
+     * ```typescript
+     * const result = await sdk.getActiveUsers({
+     *   tokenName: 'mytoken',
+     *   type: 'chat_participants',
+     *   search: 'alice', // Filter by address or name
+     * });
+     * ```
+     */
+    getActiveUsers(options: GetActiveUsersOptions): Promise<ActiveUsersResult>;
+    /**
+     * Create a new API key.
+     *
+     * **CRITICAL**: The `rawKey` in the response is ONLY shown once!
+     * Store it securely immediately - it cannot be retrieved again.
+     *
+     * API keys enable delegation of specific permissions to third-party services
+     * or automated systems without sharing full account access.
+     *
+     * Requires JWT authentication - call `sdk.login()` first.
+     *
+     * @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 chat management
+     * const result = await sdk.createApiKey({
+     *   role: 'MODERATOR',
+     *   description: 'Twitch chat bot integration',
+     *   tokenNames: ['mytoken', 'othertoken']
+     * });
+     *
+     * // CRITICAL: Save this immediately!
+     * console.log('API Key:', result.rawKey);
+     * // Format: glp_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+     *
+     * // Create an owner key for full access to all tokens
+     * const ownerKey = await sdk.createApiKey({
+     *   role: 'OWNER',
+     *   description: 'Production automation',
+     *   delegateAllTokens: true,
+     *   expiresAt: '2025-12-31T23:59:59Z'
+     * });
+     * ```
+     *
+     * @since 5.6.0
+     */
+    createApiKey(options: CreateApiKeyOptions): Promise<CreateApiKeyResponse>;
+    /**
+     * List all API keys for the authenticated user.
+     *
+     * Returns paginated list of API keys. Raw keys are never included -
+     * they are only shown once at creation time.
+     *
+     * Requires JWT authentication - call `sdk.login()` first.
+     *
+     * @param options - Optional pagination options
+     * @returns Paginated list of API keys
+     * @throws ConfigurationError if JWT auth is not configured
+     *
+     * @example
+     * ```typescript
+     * // List all API keys
+     * const result = await sdk.listApiKeys();
+     * console.log(`Total keys: ${result.meta.total}`);
+     *
+     * for (const key of result.apiKeys) {
+     *   console.log(`${key.keyPrefix} - ${key.role} - ${key.description}`);
+     *   console.log(`  Last used: ${key.lastUsedAt || 'Never'}`);
+     *   console.log(`  Expires: ${key.expiresAt || 'Never'}`);
+     * }
+     *
+     * // Paginate through keys
+     * const page2 = await sdk.listApiKeys({ page: 2, limit: 10 });
+     * ```
+     *
+     * @since 5.6.0
+     */
+    listApiKeys(options?: ListApiKeysOptions): Promise<ApiKeyListResponse>;
+    /**
+     * Get a single API key by ID.
+     *
+     * Returns the API key metadata. Raw key is never included.
+     *
+     * Requires JWT authentication - call `sdk.login()` first.
+     *
+     * @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 sdk.getApiKey(123);
+     * console.log(`Key ${key.keyPrefix}: ${key.role}`);
+     * console.log(`Description: ${key.description}`);
+     * console.log(`Delegate all tokens: ${key.delegateAllTokens}`);
+     * console.log(`Token names: ${key.tokenNames.join(', ')}`);
+     * ```
+     *
+     * @since 5.6.0
+     */
+    getApiKey(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.
+     *
+     * Requires JWT authentication - call `sdk.login()` first.
+     *
+     * @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 sdk.updateApiKey(123, {
+     *   description: 'Updated description'
+     * });
+     *
+     * // Upgrade role and extend expiration
+     * await sdk.updateApiKey(123, {
+     *   role: 'MANAGER',
+     *   expiresAt: '2026-12-31T23:59:59Z'
+     * });
+     *
+     * // Switch from specific tokens to all tokens
+     * await sdk.updateApiKey(123, {
+     *   delegateAllTokens: true
+     * });
+     * ```
+     *
+     * @since 5.6.0
+     */
+    updateApiKey(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.
+     *
+     * Requires JWT authentication - call `sdk.login()` first.
+     *
+     * @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 compromised key
+     * await sdk.revokeApiKey(123);
+     * console.log('API key revoked');
+     *
+     * // Key is now unusable
+     * // Attempts to use it will fail with 401 Unauthorized
+     * ```
+     *
+     * @since 5.6.0
+     */
+    revokeApiKey(id: number): Promise<void>;
+    /**
+     * Get all valid API key roles.
+     *
+     * Returns the list of available roles for API keys.
+     * Useful for UI dropdowns or validation.
+     *
+     * @returns Array of valid role strings
+     *
+     * @example
+     * ```typescript
+     * const roles = sdk.getApiKeyRoles();
+     * console.log('Available roles:', roles);
+     * // ['MODERATOR', 'TECHNICAL_PRODUCER', 'MANAGER', 'OWNER']
+     * ```
+     *
+     * @since 5.6.0
+     */
+    getApiKeyRoles(): string[];
+    /**
+     * Create a moderator invite for a token.
+     *
+     * Creates a magic link invite that can be shared with someone to grant them
+     * moderator access to the specified token. The recipient claims the invite
+     * after logging in, and their wallet becomes linked as a moderator.
+     *
+     * Requires JWT authentication - must be the token owner.
+     *
+     * @param options - Create invite options including tokenName, role, and optional description/expiration
+     * @returns The created invite including the magic link URL
+     *
+     * @example
+     * ```typescript
+     * const result = await sdk.createModeratorInvite({
+     *   tokenName: 'mytoken',
+     *   role: 'MODERATOR',
+     *   description: 'John - Friday evening shows'
+     * });
+     * console.log('Share this link:', result.invite.inviteUrl);
+     * ```
+     *
+     * @since 5.7.0
+     */
+    createModeratorInvite(options: CreateModeratorInviteOptions): Promise<CreateModeratorInviteResult>;
+    /**
+     * Claim a moderator invite.
+     *
+     * Claims an invite using the code from a magic link URL. The authenticated
+     * user's wallet becomes the moderator for the token with the specified role.
+     *
+     * Requires JWT authentication.
+     *
+     * @param options - Claim options including the invite code
+     * @returns The token that was added to the user's moderated tokens
+     *
+     * @example
+     * ```typescript
+     * const result = await sdk.claimModeratorInvite({
+     *   inviteCode: 'abc123def456...'
+     * });
+     * console.log('Now moderating:', result.token.tokenName);
+     * console.log('Role:', result.token.role);
+     * ```
+     *
+     * @since 5.7.0
+     */
+    claimModeratorInvite(options: ClaimModeratorInviteOptions): Promise<ClaimModeratorInviteResult>;
+    /**
+     * Get all tokens the current user moderates.
+     *
+     * Returns a paginated list of tokens where the authenticated user has claimed
+     * a moderator invite and has active access. Used for the /studio dashboard.
+     *
+     * Requires JWT authentication.
+     *
+     * @param options - Optional pagination options
+     * @returns Paginated list of moderated tokens
+     *
+     * @example
+     * ```typescript
+     * const result = await sdk.getModeratedTokens({ page: 1, limit: 20 });
+     * console.log('Moderating', result.meta.totalItems, 'tokens');
+     * for (const token of result.tokens) {
+     *   console.log(`- ${token.tokenName} (${token.role})`);
+     * }
+     * ```
+     *
+     * @since 5.7.0
+     */
+    getModeratedTokens(options?: GetModeratedTokensOptions): Promise<ModeratedTokensResult>;
+    /**
+     * List moderator invites.
+     *
+     * Returns a paginated list of moderator invites. Behavior depends on tokenName:
+     * - With tokenName: Returns invites for that specific token (verifies ownership)
+     * - Without tokenName: Returns ALL invites created by the authenticated user across all tokens
+     *
+     * Requires JWT authentication.
+     *
+     * @param options - List options including optional tokenName, status filter, and pagination
+     * @returns Paginated list of invites
+     *
+     * @example
+     * ```typescript
+     * // Get all invites across all tokens
+     * const allInvites = await sdk.listModeratorInvites({});
+     *
+     * // Get invites for a specific token
+     * const result = await sdk.listModeratorInvites({ tokenName: 'mytoken' });
+     * console.log('Total invites:', result.meta.totalItems);
+     *
+     * // Filter by status
+     * const pending = await sdk.listModeratorInvites({
+     *   tokenName: 'mytoken',
+     *   status: 'PENDING'
+     * });
+     * ```
+     *
+     * @since 5.7.0
+     */
+    listModeratorInvites(options: ListModeratorInvitesOptions): Promise<ModeratorInviteListResult>;
+    /**
+     * Revoke a moderator invite.
+     *
+     * Revokes an invite by ID, preventing it from being claimed. If already claimed,
+     * the moderator loses access to the token.
+     *
+     * Requires JWT authentication - must be the token owner.
+     *
+     * @param inviteId - The ID of the invite to revoke
+     *
+     * @example
+     * ```typescript
+     * await sdk.revokeModeratorInvite(123);
+     * console.log('Invite revoked');
+     * ```
+     *
+     * @since 5.7.0
+     */
+    revokeModeratorInvite(inviteId: number): Promise<void>;
+    /**
+     * Update the role of a moderator invite.
+     *
+     * Changes the role granted by the invite. For claimed invites, the moderator's
+     * effective permissions change immediately (enforced at runtime).
+     *
+     * Requires JWT authentication - must be the token owner.
+     *
+     * @param options - Update options including inviteId and new role
+     * @returns The updated invite
+     *
+     * @example
+     * ```typescript
+     * const result = await sdk.updateModeratorInviteRole({
+     *   inviteId: 123,
+     *   role: 'MANAGER'
+     * });
+     * console.log('Updated role:', result.invite.role);
+     * ```
+     *
+     * @since 5.7.0
+     */
+    updateModeratorInviteRole(options: UpdateInviteRoleOptions): Promise<UpdateInviteRoleResult>;
+    /**
+     * Get invite details by code (public endpoint).
+     *
+     * Returns public information about an invite for the claim page. This is used
+     * by the frontend to display invite details before the user logs in to claim.
+     *
+     * No authentication required.
+     *
+     * @param inviteCode - The invite code from the magic link URL
+     * @returns Public invite information
+     *
+     * @example
+     * ```typescript
+     * const info = await sdk.getModeratorInviteByCode('abc123def456...');
+     * console.log(`Invited to moderate ${info.tokenName} as ${info.role}`);
+     * console.log(`Invited by: ${info.invitedBy.fullName || info.invitedBy.address}`);
+     * ```
+     *
+     * @since 5.7.0
+     */
+    getModeratorInviteByCode(inviteCode: string): Promise<PublicInviteInfo>;
+    /**
+     * Create a content flag/report.
+     *
+     * Two-tier system:
+     * - Chat/Comment: reason and details are optional (one-click flag)
+     * - Stream: reason is required (modal flow)
+     *
+     * @param options - Flag creation options
+     * @returns Created flag data
+     * @throws Error if not authenticated or validation fails
+     *
+     * @since 5.8.0
+     * @category Flags
+     *
+     * @example One-click flag on chat message
+     * ```typescript
+     * const result = await sdk.createFlag({
+     *   tokenName: 'mytoken',
+     *   contentType: ContentType.CHAT_MESSAGE,
+     *   contentId: 'msg-123',
+     *   reportedUserAddress: 'eth|abc...',
+     * });
+     * ```
+     *
+     * @example Stream report with required reason
+     * ```typescript
+     * const result = await sdk.createFlag({
+     *   tokenName: 'mytoken',
+     *   contentType: ContentType.STREAM,
+     *   contentId: 'stream-456',
+     *   reportedUserAddress: 'eth|abc...',
+     *   reason: FlagReason.INAPPROPRIATE_CONTENT,
+     *   details: 'Explicit content',
+     * });
+     * ```
+     */
+    createFlag(options: CreateFlagOptions): Promise<CreateFlagResult>;
+    /**
+     * List flags for a token with pagination and filtering.
+     *
+     * Authorization varies by content type:
+     * - CHAT_MESSAGE/COMMENT: Owner or Moderator (JWT) can view
+     * - STREAM: Admin API key only
+     *
+     * @param options - List options with filters
+     * @returns Paginated list of flags
+     * @throws Error if not authorized
+     *
+     * @since 5.8.0
+     * @category Flags
+     *
+     * @example List pending flags
+     * ```typescript
+     * const result = await sdk.listFlags({
+     *   tokenName: 'mytoken',
+     *   status: FlagStatus.PENDING,
+     * });
+     * console.log(`Found ${result.flags.length} pending flags`);
+     * ```
+     *
+     * @example List flags with pagination
+     * ```typescript
+     * const result = await sdk.listFlags({
+     *   tokenName: 'mytoken',
+     *   contentType: ContentType.CHAT_MESSAGE,
+     *   page: 1,
+     *   limit: 50,
+     * });
+     * ```
+     */
+    listFlags(options: ListFlagsOptions): Promise<FlagListResult>;
+    /**
+     * List flags globally across all tokens (Overseer only).
+     *
+     * Returns paginated flags matching filter criteria across the platform.
+     * Requires OVERSEER role for access.
+     *
+     * @param options - Filter and pagination options
+     * @returns Paginated list of flags
+     * @throws Error if not authorized as overseer
+     *
+     * @since 6.2.0
+     * @category Flags
+     */
+    listGlobalFlags(options?: ListGlobalFlagsOptions): Promise<FlagListResult>;
+    /**
+     * Dismiss a flag (no action taken).
+     *
+     * Marks the flag as reviewed but takes no action on the content.
+     *
+     * @param options - Dismiss options
+     * @returns Updated flag data
+     * @throws Error if not authorized or flag not found
+     *
+     * @since 5.8.0
+     * @category Flags
+     *
+     * @example Dismiss a flag
+     * ```typescript
+     * const result = await sdk.dismissFlag({ flagId: 123 });
+     * console.log(result.flag.status); // 'DISMISSED'
+     * ```
+     */
+    dismissFlag(options: DismissFlagOptions): Promise<DismissFlagResult>;
+    /**
+     * Take action on a flag.
+     *
+     * Actions available:
+     * - DELETE_CONTENT: Remove the flagged content
+     * - BAN_USER: Ban the reported user from the token
+     * - DELETE_AND_BAN: Both delete content and ban user
+     *
+     * @param options - Action options
+     * @returns Updated flag data with action taken
+     * @throws Error if not authorized, flag not found, or action invalid
+     *
+     * @since 5.8.0
+     * @category Flags
+     *
+     * @example Delete the flagged content
+     * ```typescript
+     * const result = await sdk.actionFlag({
+     *   flagId: 123,
+     *   action: FlagAction.DELETE_CONTENT,
+     * });
+     * ```
+     *
+     * @example Delete content and ban user
+     * ```typescript
+     * const result = await sdk.actionFlag({
+     *   flagId: 123,
+     *   action: FlagAction.DELETE_AND_BAN,
+     * });
+     * ```
+     */
+    actionFlag(options: ActionFlagOptions): Promise<ActionFlagResult>;
+    /**
+     * Create an overseer invite.
+     *
+     * Overseers have global platform access with MANAGER-level permissions
+     * across ALL tokens (current and future). This is different from moderators
+     * who have token-scoped access.
+     *
+     * Requires Admin API key OR JWT as existing Overseer.
+     *
+     * @param options - Optional description and expiration settings
+     * @returns Created invite data including the invite URL
+     * @throws ConfigurationError if neither auth method is available
+     * @throws ValidationError if parameters are invalid
+     *
+     * @since 5.9.0
+     * @category Overseer
+     *
+     * @example Create an invite with description
+     * ```typescript
+     * const result = await sdk.createOverseerInvite({
+     *   description: 'John - Platform Support Team',
+     * });
+     * console.log('Share this link:', result.invite.inviteUrl);
+     * ```
+     *
+     * @example Create invite with expiration
+     * ```typescript
+     * const result = await sdk.createOverseerInvite({
+     *   description: 'Temporary access',
+     *   expiresAt: '2025-12-31T23:59:59Z',
+     * });
+     * ```
+     */
+    createOverseerInvite(options?: CreateOverseerInviteOptions): Promise<{
+        invite: OverseerInviteWithUrl;
+    }>;
+    /**
+     * List all overseer invites.
+     *
+     * Requires Admin API key OR JWT as existing Overseer.
+     *
+     * @param options - Optional filter and pagination options
+     * @returns Paginated list of invites
+     * @throws ConfigurationError if neither auth method is available
+     *
+     * @since 5.9.0
+     * @category Overseer
+     *
+     * @example List all invites
+     * ```typescript
+     * const result = await sdk.listOverseerInvites();
+     * console.log(`Total invites: ${result.meta.totalItems}`);
+     * ```
+     *
+     * @example Filter by status with pagination
+     * ```typescript
+     * const result = await sdk.listOverseerInvites({
+     *   status: 'PENDING',
+     *   page: 1,
+     *   limit: 10,
+     * });
+     * ```
+     */
+    listOverseerInvites(options?: ListOverseerInvitesOptions): Promise<PaginatedOverseerInvites>;
+    /**
+     * Get overseer invite details by code.
+     *
+     * This is a public endpoint used by the frontend claim page to display
+     * invite information before the user logs in to claim.
+     *
+     * @param inviteCode - The invite code from the magic link URL
+     * @returns Public invite information (description, status, inviter info)
+     * @throws ValidationError if invite code format is invalid
+     * @throws Error if invite not found (404)
+     *
+     * @since 5.9.0
+     * @category Overseer
+     *
+     * @example Get invite info before claiming
+     * ```typescript
+     * const info = await sdk.getOverseerInviteByCode('abc123def456...');
+     * console.log(`Invited by: ${info.invitedBy.fullName || info.invitedBy.address}`);
+     * console.log(`Status: ${info.status}`);
+     * ```
+     */
+    getOverseerInviteByCode(inviteCode: string): Promise<PublicOverseerInviteInfo>;
+    /**
+     * Claim an overseer invite.
+     *
+     * The authenticated user's wallet becomes an overseer with global access
+     * to ALL tokens on the platform.
+     *
+     * Requires JWT authentication.
+     *
+     * @param inviteCode - The invite code from the magic link URL
+     * @returns The claimed invite data
+     * @throws ValidationError if invite code is invalid or invite already claimed/revoked/expired
+     * @throws ConfigurationError if JWT is not configured
+     *
+     * @since 5.9.0
+     * @category Overseer
+     *
+     * @example Claim an invite
+     * ```typescript
+     * const result = await sdk.claimOverseerInvite('abc123def456...');
+     * console.log('Now an overseer! Status:', result.invite.status);
+     * ```
+     */
+    claimOverseerInvite(inviteCode: string): Promise<{
+        invite: OverseerInviteWithUrl;
+    }>;
+    /**
+     * Revoke an overseer invite.
+     *
+     * This revokes the invite, preventing it from being claimed.
+     * If the invite was already claimed, the overseer loses access.
+     *
+     * Requires Admin API key OR JWT as existing Overseer.
+     *
+     * @param inviteId - The ID of the invite to revoke
+     * @throws ValidationError if invite ID is invalid
+     * @throws ConfigurationError if neither auth method is available
+     * @throws Error if invite not found (404)
+     *
+     * @since 5.9.0
+     * @category Overseer
+     *
+     * @example Revoke an invite
+     * ```typescript
+     * await sdk.revokeOverseerInvite(123);
+     * console.log('Invite revoked');
+     * ```
+     */
+    revokeOverseerInvite(inviteId: number): Promise<void>;
+    /**
+     * List all overseers.
+     *
+     * Requires Admin API key OR JWT as existing Overseer.
+     *
+     * @param options - Optional filter and pagination options
+     * @returns Paginated list of overseers
+     * @throws ConfigurationError if neither auth method is available
+     *
+     * @since 5.9.0
+     * @category Overseer
+     *
+     * @example List all overseers
+     * ```typescript
+     * const result = await sdk.listOverseers();
+     * console.log(`Total overseers: ${result.meta.totalItems}`);
+     * ```
+     *
+     * @example Filter by status
+     * ```typescript
+     * const active = await sdk.listOverseers({
+     *   status: 'ACTIVE',
+     * });
+     * ```
+     */
+    listOverseers(options?: ListOverseersOptions): Promise<PaginatedOverseers>;
+    /**
+     * Revoke an overseer's access.
+     *
+     * This revokes the overseer's global platform access.
+     *
+     * Requires Admin API key OR JWT as existing Overseer.
+     *
+     * @param address - The wallet address of the overseer to revoke
+     * @throws ValidationError if address format is invalid
+     * @throws ConfigurationError if neither auth method is available
+     * @throws Error if overseer not found (404)
+     *
+     * @since 5.9.0
+     * @category Overseer
+     *
+     * @example Revoke an overseer
+     * ```typescript
+     * await sdk.revokeOverseer('eth|1234567890abcdef...');
+     * console.log('Overseer access revoked');
+     * ```
+     */
+    revokeOverseer(address: string): Promise<void>;
+    /**
+     * Check own overseer status.
+     *
+     * Returns whether the authenticated user is currently an active overseer
+     * and their details if so.
+     *
+     * Requires JWT authentication.
+     *
+     * @returns Overseer status including details if active
+     * @throws ConfigurationError if JWT is not configured
+     *
+     * @since 5.9.0
+     * @category Overseer
+     *
+     * @example Check your overseer status
+     * ```typescript
+     * const status = await sdk.getMyOverseerStatus();
+     * if (status.isOverseer) {
+     *   console.log('You are an overseer!');
+     *   console.log('Access granted:', status.overseer?.createdAt);
+     * } else {
+     *   console.log('You are not an overseer');
+     * }
+     * ```
+     */
+    getMyOverseerStatus(): Promise<OverseerStatusResponse>;
+    /**
+     * Get platform summary for CCTV dashboard.
+     *
+     * Returns quick counts for the overseer monitoring dashboard:
+     * - Active streams (pools with live streams)
+     * - Total viewers across all active streams
+     * - Pending content flags awaiting review
+     * - Total pools on the platform
+     *
+     * @returns Platform summary with counts
+     * @throws ConfigurationError if neither auth method is available
+     *
+     * @since 5.10.0
+     * @category Overseer
+     *
+     * @example Get platform summary
+     * ```typescript
+     * const summary = await sdk.getOverseerSummary();
+     * console.log(`Active streams: ${summary.activeStreams}`);
+     * console.log(`Total viewers: ${summary.totalViewers}`);
+     * console.log(`Pending flags: ${summary.pendingFlags}`);
+     * console.log(`Total pools: ${summary.totalPools}`);
+     * ```
+     */
+    getOverseerSummary(): Promise<OverseerSummaryResponse>;
+    /**
+     * List users with activity metrics (Admin/Overseer only - v6.x.0+)
+     *
+     * Lists all platform users with their activity metrics including
+     * comments posted, messages sent, trades, and trading volume.
+     *
+     * Requires either Admin API key or JWT with overseer status.
+     *
+     * @param options List options including search, sorting, and pagination
+     * @returns Paginated list of users with activity metrics
+     * @throws ConfigurationError if neither admin API key nor JWT is configured
+     * @throws ValidationError if options are invalid
+     *
+     * @since 6.x.0
+     * @category Overseer
+     *
+     * @example List users with pagination
+     * ```typescript
+     * const result = await sdk.listOverseerUsers({ page: 1, limit: 20 });
+     * result.items.forEach(user => {
+     *   console.log(`${user.profile.fullName}: ${user.metrics.commentCount} comments`);
+     * });
+     * ```
+     *
+     * @example Search and sort
+     * ```typescript
+     * const result = await sdk.listOverseerUsers({
+     *   search: 'alice',
+     *   sortBy: 'activity',
+     *   sortOrder: 'desc',
+     *   limit: 10
+     * });
+     * ```
+     */
+    listOverseerUsers(options?: ListUsersOptions): Promise<UsersListResponse>;
+    /**
+     * Get comprehensive user summary (Admin/Overseer only - v6.x.0+)
+     *
+     * Retrieves full profile, activity metrics, and ban status for a specific user.
+     * Useful for overseer dashboard user detail pages.
+     *
+     * Requires either Admin API key or JWT with overseer status.
+     *
+     * @param address User wallet address
+     * @returns User profile with detailed activity metrics and ban status
+     * @throws ConfigurationError if neither admin API key nor JWT is configured
+     * @throws ValidationError if address format is invalid
+     *
+     * @since 6.x.0
+     * @category Overseer
+     *
+     * @example Get user summary
+     * ```typescript
+     * const summary = await sdk.getOverseerUserSummary('eth|abc123...');
+     * console.log(`User: ${summary.profile.fullName}`);
+     * console.log(`Comments: ${summary.metrics.commentCount}`);
+     * console.log(`Banned: ${summary.isBanned}`);
+     * if (summary.isBanned) {
+     *   console.log(`Reason: ${summary.banInfo?.reason}`);
+     * }
+     * ```
+     */
+    getOverseerUserSummary(address: string): Promise<UserSummaryResponse>;
+    /**
+     * Ban a token from the platform (overseer only).
+     *
+     * When a token is banned:
+     * - Hidden from ALL pool listings (including creator's profile)
+     * - Comments blocked on banned tokens
+     * - Live streaming blocked on banned tokens
+     * - Chat messages blocked on banned tokens
+     * - Trading NOT blocked (GalaChain handles trading independently)
+     *
+     * Requires either Admin API key or JWT with overseer status.
+     *
+     * @param options - Ban options including tokenName and optional reason
+     * @returns Created ban data with token name
+     * @throws ValidationError if parameters are invalid
+     * @throws ConfigurationError if neither admin API key nor JWT is configured
+     * @throws Error if token is already banned (409 Conflict)
+     *
+     * @since 6.x.0
+     * @category TokenBan
+     *
+     * @example Ban a token with reason
+     * ```typescript
+     * const result = await sdk.banToken({
+     *   tokenName: 'scamtoken',
+     *   reason: 'Fraudulent project - reported by multiple users'
+     * });
+     * console.log('Banned token:', result.tokenName);
+     * console.log('Ban ID:', result.ban.id);
+     * console.log('Banned by:', result.ban.bannedBy);
+     * ```
+     *
+     * @example Ban without reason
+     * ```typescript
+     * await sdk.banToken({ tokenName: 'problematictoken' });
+     * ```
+     */
+    banToken(options: BanTokenOptions): Promise<BanTokenResult>;
+    /**
+     * Remove a ban from a token (overseer only).
+     *
+     * When a token is unbanned:
+     * - Restored to all pool listings
+     * - Visible on creator's profile again
+     * - Comments re-enabled
+     * - Live streaming re-enabled
+     * - Chat re-enabled
+     *
+     * Requires either Admin API key or JWT with overseer status.
+     *
+     * @param options - Unban options including tokenName
+     * @returns Removal confirmation with token name
+     * @throws ValidationError if token name is invalid
+     * @throws ConfigurationError if neither admin API key nor JWT is configured
+     * @throws Error if token is not banned (404 Not Found)
+     *
+     * @since 6.x.0
+     * @category TokenBan
+     *
+     * @example
+     * ```typescript
+     * const result = await sdk.unbanToken({ tokenName: 'scamtoken' });
+     * console.log('Removed ban:', result.removed); // true
+     * console.log('Token:', result.tokenName);
+     * ```
+     */
+    unbanToken(options: UnbanTokenOptions): Promise<UnbanTokenResult>;
+    /**
+     * List all banned tokens (overseer only).
+     *
+     * Returns paginated list of banned tokens with full details.
+     *
+     * Requires either Admin API key or JWT with overseer status.
+     *
+     * @param options - Optional pagination and search parameters
+     * @returns Paginated list of banned tokens
+     * @throws ValidationError if pagination parameters are invalid
+     * @throws ConfigurationError if neither admin API key nor JWT is configured
+     *
+     * @since 6.x.0
+     * @category TokenBan
+     *
+     * @example List all banned tokens
+     * ```typescript
+     * const result = await sdk.listTokenBans();
+     * console.log(`Total banned: ${result.meta.total}`);
+     * for (const ban of result.items) {
+     *   console.log(`${ban.tokenName}: ${ban.reason || 'No reason'}`);
+     * }
+     * ```
+     *
+     * @example Search for specific tokens
+     * ```typescript
+     * const result = await sdk.listTokenBans({
+     *   search: 'scam',
+     *   page: 1,
+     *   limit: 10
+     * });
+     * ```
+     *
+     * @example Paginate through all bans
+     * ```typescript
+     * let page = 1;
+     * let hasMore = true;
+     * while (hasMore) {
+     *   const result = await sdk.listTokenBans({ page, limit: 20 });
+     *   console.log('Bans:', result.items.map(b => b.tokenName));
+     *   hasMore = page < result.meta.totalPages;
+     *   page++;
+     * }
+     * ```
+     */
+    listTokenBans(options?: ListTokenBansOptions): Promise<TokenBanListResult>;
+    /**
+     * Get ban details for a specific token (overseer only).
+     *
+     * Returns ban data if banned, or indicates not banned.
+     * Use this to get full ban details including reason and who banned it.
+     *
+     * Requires either Admin API key or JWT with overseer status.
+     *
+     * @param options - Options including tokenName
+     * @returns Ban status with full details if banned
+     * @throws ValidationError if token name is invalid
+     * @throws ConfigurationError if neither admin API key nor JWT is configured
+     *
+     * @since 6.x.0
+     * @category TokenBan
+     *
+     * @example
+     * ```typescript
+     * const status = await sdk.getTokenBan({ tokenName: 'sometoken' });
+     * if (status.banned) {
+     *   console.log('Token is banned');
+     *   console.log('Reason:', status.ban?.reason);
+     *   console.log('Banned by:', status.ban?.bannedBy);
+     *   console.log('Banned at:', status.ban?.createdAt);
+     * } else {
+     *   console.log('Token is not banned');
+     * }
+     * ```
+     */
+    getTokenBan(options: GetTokenBanOptions): Promise<TokenBanStatusResult>;
+    /**
+     * Check if a token is banned (overseer only).
+     *
+     * Convenience alias for getTokenBan() - provided for semantic clarity.
+     * Use when you just need to check if a token is banned.
+     *
+     * Requires either Admin API key or JWT with overseer status.
+     *
+     * @param options - Options including tokenName
+     * @returns Ban status with full details if banned
+     * @throws ValidationError if token name is invalid
+     * @throws ConfigurationError if neither admin API key nor JWT is configured
+     *
+     * @since 6.x.0
+     * @category TokenBan
+     *
+     * @example
+     * ```typescript
+     * const status = await sdk.isTokenBanned({ tokenName: 'sometoken' });
+     * if (status.banned) {
+     *   console.log('Token is banned:', status.ban?.reason);
+     * }
+     * ```
+     */
+    isTokenBanned(options: GetTokenBanOptions): Promise<TokenBanStatusResult>;
+    /**
+     * Add a reaction to a pool message (chat or comment).
+     *
+     * Requires JWT or API key authentication.
+     * Adding the same reaction type again is a no-op (idempotent).
+     * Users can have multiple different reaction types on the same message.
+     *
+     * @param options - Options including tokenName, messageId, and reactionType
+     * @returns Updated reaction data and whether reaction was newly created
+     * @throws ValidationError if parameters are invalid
+     * @throws ConfigurationError if authentication is not configured
+     *
+     * @since 5.12.0
+     * @category ContentReactions
+     *
+     * @example Add a heart reaction
+     * ```typescript
+     * const result = await sdk.addContentReaction({
+     *   tokenName: 'mytoken',
+     *   messageId: 'msg-1703443200000-a1b2c3d4e5f6789012345678901234ab',
+     *   reactionType: 'heart'
+     * });
+     * console.log('Created:', result.created);
+     * console.log('Total reactions:', result.data.totalCount);
+     * ```
+     */
+    addContentReaction(options: AddContentReactionOptions): Promise<AddContentReactionResult>;
+    /**
+     * Remove a reaction from a pool message.
+     *
+     * Requires JWT or API key authentication.
+     * Only the user who created the reaction can remove it.
+     *
+     * @param options - Options including tokenName, messageId, and reactionType
+     * @returns Success indicator
+     * @throws ValidationError if parameters are invalid
+     * @throws ConfigurationError if authentication is not configured
+     *
+     * @since 5.12.0
+     * @category ContentReactions
+     *
+     * @example Remove a heart reaction
+     * ```typescript
+     * await sdk.removeContentReaction({
+     *   tokenName: 'mytoken',
+     *   messageId: 'msg-1703443200000-a1b2c3d4e5f6789012345678901234ab',
+     *   reactionType: 'heart'
+     * });
+     * ```
+     */
+    removeContentReaction(options: RemoveContentReactionOptions): Promise<RemoveContentReactionResult>;
+    /**
+     * Add a reaction to a chat message.
+     *
+     * Convenience wrapper for addContentReaction specifically for chat messages.
+     *
+     * @param options - Options including tokenName, messageId, and reactionType
+     * @returns Updated reaction data
+     *
+     * @since 5.12.0
+     * @category ContentReactions
+     *
+     * @example Add a fire reaction to a chat message
+     * ```typescript
+     * await sdk.addReactionToChatMessage({
+     *   tokenName: 'mytoken',
+     *   messageId: 'msg-1703443200000-a1b2c3d4e5f6789012345678901234ab',
+     *   reactionType: 'fire'
+     * });
+     * ```
+     */
+    addReactionToChatMessage(options: AddContentReactionOptions): Promise<AddContentReactionResult>;
+    /**
+     * Remove a reaction from a chat message.
+     *
+     * Convenience wrapper for removeContentReaction specifically for chat messages.
+     *
+     * @param options - Options including tokenName, messageId, and reactionType
+     * @returns Success indicator
+     *
+     * @since 5.12.0
+     * @category ContentReactions
+     *
+     * @example Remove a fire reaction from a chat message
+     * ```typescript
+     * await sdk.removeReactionFromChatMessage({
+     *   tokenName: 'mytoken',
+     *   messageId: 'msg-1703443200000-a1b2c3d4e5f6789012345678901234ab',
+     *   reactionType: 'fire'
+     * });
+     * ```
+     */
+    removeReactionFromChatMessage(options: RemoveContentReactionOptions): Promise<RemoveContentReactionResult>;
+    /**
+     * Add a reaction to a comment.
+     *
+     * Convenience wrapper for addContentReaction specifically for comments.
+     *
+     * @param options - Options including tokenName, messageId, and reactionType
+     * @returns Updated reaction data
+     *
+     * @since 5.12.0
+     * @category ContentReactions
+     *
+     * @example Add a thumbs_up reaction to a comment
+     * ```typescript
+     * await sdk.addReactionToComment({
+     *   tokenName: 'mytoken',
+     *   messageId: 'msg-1703443200000-a1b2c3d4e5f6789012345678901234ab',
+     *   reactionType: 'thumbs_up'
+     * });
+     * ```
+     */
+    addReactionToComment(options: AddContentReactionOptions): Promise<AddContentReactionResult>;
+    /**
+     * Remove a reaction from a comment.
+     *
+     * Convenience wrapper for removeContentReaction specifically for comments.
+     *
+     * @param options - Options including tokenName, messageId, and reactionType
+     * @returns Success indicator
+     *
+     * @since 5.12.0
+     * @category ContentReactions
+     *
+     * @example Remove a thumbs_up reaction from a comment
+     * ```typescript
+     * await sdk.removeReactionFromComment({
+     *   tokenName: 'mytoken',
+     *   messageId: 'msg-1703443200000-a1b2c3d4e5f6789012345678901234ab',
+     *   reactionType: 'thumbs_up'
+     * });
+     * ```
+     */
+    removeReactionFromComment(options: RemoveContentReactionOptions): Promise<RemoveContentReactionResult>;
+    /**
+     * Get comments with optional filtering.
+     *
+     * Public endpoint - no authentication required.
+     * At least one of tokenName or userAddress must be provided.
+     *
+     * @param options Query options including tokenName/userAddress and pagination
+     * @returns Paginated list of comments
+     * @throws ValidationError if no filter is provided or options are invalid
+     *
+     * @since 6.2.0
+     * @category Comments
+     *
+     * @example Get comments for a token
+     * ```typescript
+     * const { messages, meta } = await sdk.getComments({ tokenName: 'mytoken' });
+     * console.log(`Page ${meta.currentPage} of ${meta.totalPages}`);
+     * messages.forEach(comment => {
+     *   console.log(`${comment.userProfile?.fullName}: ${comment.content}`);
+     * });
+     * ```
+     *
+     * @example Get comments by a user
+     * ```typescript
+     * const result = await sdk.getComments({
+     *   userAddress: 'eth|0x123...',
+     *   page: 2,
+     *   limit: 20
+     * });
+     * ```
+     */
+    getComments(options: GetCommentsOptions): Promise<CommentsResult>;
+    /**
+     * Create a new comment on a token pool.
+     *
+     * Requires JWT authentication.
+     *
+     * @param options Create options including tokenName and content
+     * @returns The created comment
+     * @throws ValidationError if token name or content is invalid
+     * @throws ConfigurationError if JWT is not configured
+     *
+     * @since 6.2.0
+     * @category Comments
+     *
+     * @example Create a comment
+     * ```typescript
+     * const result = await sdk.createComment({
+     *   tokenName: 'mytoken',
+     *   content: 'This is a great project!'
+     * });
+     * console.log('Created comment ID:', result.comment.id);
+     * ```
+     */
+    createComment(options: CreateCommentOptions): Promise<CreateCommentResult>;
+    /**
+     * Update a comment.
+     *
+     * Requires JWT authentication. Only the comment author can update.
+     *
+     * @param id Message ID of the comment to update
+     * @param options Update options including new content
+     * @returns The updated comment
+     * @throws ValidationError if ID or content is invalid
+     * @throws ConfigurationError if JWT is not configured
+     *
+     * @since 6.2.0
+     * @category Comments
+     *
+     * @example Update a comment
+     * ```typescript
+     * const result = await sdk.updateComment('msg-1234567890123-abc...', {
+     *   content: 'Updated comment content'
+     * });
+     * console.log('Updated at:', result.comment.updatedAt);
+     * ```
+     */
+    updateComment(id: string, options: UpdateCommentOptions): Promise<UpdateCommentResult>;
+    /**
+     * Delete a comment.
+     *
+     * Requires authentication (JWT or API key).
+     * Authorization: comment author, pool creator, moderator with MANAGE_COMMENTS permission, or overseer.
+     *
+     * @param id Message ID of the comment to delete
+     * @returns Success indicator
+     * @throws ValidationError if ID is invalid
+     * @throws ConfigurationError if neither JWT nor API key is configured
+     *
+     * @since 6.2.0
+     * @category Comments
+     *
+     * @example Delete a comment
+     * ```typescript
+     * await sdk.deleteComment('msg-1234567890123-abc...');
+     * console.log('Comment deleted');
+     * ```
+     */
+    deleteComment(id: string): Promise<DeleteCommentResult>;
+    /**
+     * Get chat messages with optional filtering.
+     *
+     * Public endpoint - no authentication required.
+     * At least one of tokenName or userAddress must be provided.
+     *
+     * @param options Query options including tokenName/userAddress and pagination
+     * @returns Paginated list of chat messages
+     * @throws ValidationError if no filter is provided or options are invalid
+     *
+     * @since 6.2.0
+     * @category Chat
+     *
+     * @example Get chat messages for a token
+     * ```typescript
+     * const { messages, meta } = await sdk.getChatMessages({ tokenName: 'anime' });
+     * console.log(`Found ${meta.totalItems} messages`);
+     * messages.forEach(msg => {
+     *   console.log(`${msg.userProfile?.fullName}: ${msg.content}`);
+     * });
+     * ```
+     *
+     * @example Get chat messages by a user
+     * ```typescript
+     * const result = await sdk.getChatMessages({
+     *   userAddress: 'eth|0x123...',
+     *   page: 1,
+     *   limit: 50
+     * });
+     * ```
+     */
+    getChatMessages(options: GetChatMessagesOptions): Promise<GetChatMessagesResult>;
+    /**
+     * Send a chat message.
+     *
+     * Requires JWT authentication.
+     *
+     * @param options Send options including tokenName and content
+     * @returns The created chat message
+     * @throws ValidationError if token name or content is invalid
+     * @throws ConfigurationError if JWT is not configured
+     *
+     * @since 6.2.0
+     * @category Chat
+     *
+     * @example Send a chat message
+     * ```typescript
+     * const result = await sdk.sendChatMessage({
+     *   tokenName: 'anime',
+     *   content: 'Hello everyone!'
+     * });
+     * console.log('Message sent:', result.message.id);
+     * ```
+     */
+    sendChatMessage(options: CreateChatMessageOptions): Promise<CreateChatMessageResult>;
+    /**
+     * Update a chat message.
+     *
+     * Requires JWT authentication. Only the message author can update.
+     *
+     * @param id Message ID to update (format: chat-{timestamp}-{uuid})
+     * @param options Update options including new content
+     * @returns The updated chat message
+     * @throws ValidationError if ID or content is invalid
+     * @throws ConfigurationError if JWT is not configured
+     *
+     * @since 6.2.0
+     * @category Chat
+     *
+     * @example Update a chat message
+     * ```typescript
+     * const result = await sdk.updateChatMessage(
+     *   'chat-1734445623456-550e8400-e29b-41d4-a716-446655440000',
+     *   { content: 'Updated message' }
+     * );
+     * console.log('Updated:', result.message.updatedAt);
+     * ```
+     */
+    updateChatMessage(id: string, options: UpdateChatMessageOptions): Promise<UpdateChatMessageResult>;
+    /**
+     * Delete a chat message.
+     *
+     * Supports both JWT and API key authentication.
+     * Authorization: message author, pool owner, or MANAGE_CHAT permission.
+     *
+     * @param id Message ID to delete (format: chat-{timestamp}-{uuid})
+     * @throws ValidationError if ID format is invalid
+     * @throws ConfigurationError if neither JWT nor API key is configured
+     *
+     * @since 6.2.0
+     * @category Chat
+     *
+     * @example Delete a chat message
+     * ```typescript
+     * await sdk.deleteChatMessage('chat-1734445623456-550e8400-e29b-41d4-a716-446655440000');
+     * console.log('Message deleted');
+     * ```
+     */
+    deleteChatMessage(id: string): Promise<void>;
+    /**
+     * Get trades with flexible filtering.
+     *
+     * Public endpoint - no authentication required.
+     * Filter by tokenName, userAddress, or both.
+     * At least one filter is required.
+     *
+     * This is the unified trades endpoint that provides flexible querying
+     * for trade history across tokens and users.
+     *
+     * @param options Query options with tokenName and/or userAddress
+     * @returns Paginated list of trades with metadata
+     * @throws ValidationError if neither tokenName nor userAddress provided
+     * @throws ValidationError if options contain invalid values
+     *
+     * @since 6.2.0
+     * @category Trades
+     *
+     * @example Get all trades for a token
+     * ```typescript
+     * const { trades, meta } = await sdk.getTrades({ tokenName: 'anime' });
+     * console.log(`Found ${meta.totalItems} trades`);
+     * trades.forEach(trade => {
+     *   console.log(`${trade.txnType}: ${trade.inputAmount} -> ${trade.outputAmount}`);
+     * });
+     * ```
+     *
+     * @example Get all trades by a user
+     * ```typescript
+     * const { trades, meta } = await sdk.getTrades({
+     *   userAddress: 'eth|1234567890abcdef...'
+     * });
+     * console.log(`User has ${meta.totalItems} trades across all tokens`);
+     * ```
+     *
+     * @example Get a user's trades on a specific token with pagination
+     * ```typescript
+     * const { trades, meta } = await sdk.getTrades({
+     *   tokenName: 'anime',
+     *   userAddress: 'eth|1234567890abcdef...',
+     *   page: 2,
+     *   limit: 20
+     * });
+     * console.log(`Page ${meta.currentPage} of ${meta.totalPages}`);
+     * ```
+     */
+    getTrades(options: GetTradesOptions): Promise<TradesQueryResult>;
+    /**
+     * Connect to the stream WebSocket server.
+     *
+     * Establishes a WebSocket connection for real-time stream events.
+     * Must be called before subscribing to streams or sending chat messages.
+     *
+     * @param callbacks - Event callback handlers
+     * @returns Promise resolving when connected
+     * @throws Error if streamWebSocketUrl is not configured
+     *
+     * @since 5.1.0
+     * @category WebSocket
+     *
+     * @example Connect with event handlers
+     * ```typescript
+     * await sdk.connectStreamWebSocket({
+     *   onStreamStatus: (event) => {
+     *     console.log(`Stream ${event.tokenName}: ${event.status}`);
+     *   },
+     *   onViewerCount: (event) => {
+     *     console.log(`Viewers: ${event.viewerCount}`);
+     *   },
+     *   onChatMessage: (event) => {
+     *     console.log(`Chat: ${event.message.content}`);
+     *   },
+     * });
+     * ```
+     */
+    connectStreamWebSocket(callbacks?: StreamEventCallbacks): Promise<void>;
+    /**
+     * Authenticate the stream WebSocket connection.
+     *
+     * Required before sending chat messages via WebSocket.
+     * Uses the configured wallet for authentication.
+     *
+     * @returns Promise resolving when authenticated
+     * @throws Error if not connected
+     * @throws Error if wallet is not configured
+     *
+     * @since 5.1.0
+     * @category WebSocket
+     *
+     * @example Authenticate for chat
+     * ```typescript
+     * await sdk.connectStreamWebSocket();
+     * await sdk.authenticateStreamWebSocket();
+     * // Now can send chat messages via WebSocket
+     * ```
+     */
+    authenticateStreamWebSocket(): Promise<void>;
+    /**
+     * Subscribe to real-time events for a stream.
+     *
+     * Joins the stream room to receive status updates, viewer counts, and chat messages.
+     *
+     * @param tokenName - Token name (lowercase)
+     * @returns Promise resolving when subscribed
+     * @throws Error if not connected
+     *
+     * @since 5.1.0
+     * @category WebSocket
+     *
+     * @example Subscribe to a stream
+     * ```typescript
+     * await sdk.connectStreamWebSocket({
+     *   onStreamStatus: (e) => console.log(`Status: ${e.status}`),
+     *   onViewerCount: (e) => console.log(`Viewers: ${e.viewerCount}`),
+     * });
+     * await sdk.subscribeToStream('mytoken');
+     * // Events will now fire for 'mytoken'
+     * ```
+     */
+    subscribeToStream(tokenName: string): Promise<StreamSubscribedEvent>;
+    /**
+     * Unsubscribe from a stream's events.
+     *
+     * Leaves the stream room and stops receiving events.
+     *
+     * @param tokenName - Token name (lowercase)
+     * @returns Promise resolving when unsubscribed
+     * @throws Error if not connected
+     *
+     * @since 5.1.0
+     * @category WebSocket
+     */
+    unsubscribeFromStream(tokenName: string): Promise<void>;
+    /**
+     * Send a chat message via WebSocket.
+     *
+     * Sends a chat message through the WebSocket connection for lower latency
+     * than the REST API. Requires prior authentication.
+     *
+     * @param tokenName - Token name (lowercase)
+     * @param content - Message content
+     * @returns Promise resolving when sent
+     * @throws Error if not connected or authenticated
+     *
+     * @since 5.1.0
+     * @category WebSocket
+     *
+     * @example Send chat via WebSocket
+     * ```typescript
+     * await sdk.connectStreamWebSocket();
+     * await sdk.authenticateStreamWebSocket();
+     * await sdk.subscribeToStream('mytoken');
+     * await sdk.sendStreamChatViaWebSocket('mytoken', 'Hello!');
+     * ```
+     */
+    sendStreamChatViaWebSocket(tokenName: string, content: string): Promise<void>;
+    /**
+     * Send an ephemeral emoji reaction to a live stream.
+     *
+     * Reactions are broadcast to all viewers via WebSocket but NOT persisted to database.
+     * Rate limiting is enforced server-side (burst of 10, then 0.5/sec refill).
+     *
+     * @param tokenName - Token name (lowercase)
+     * @param emoji - Emoji to send (single emoji or short sequence, max 15 chars)
+     * @param streamTime - Current stream timecode in seconds (for viewer sync, defaults to 0)
+     * @returns Promise resolving when sent
+     * @throws Error if not connected or authenticated
+     *
+     * @since 5.2.0
+     * @category WebSocket
+     *
+     * @example Send a reaction during a live stream
+     * ```typescript
+     * await sdk.connectStreamWebSocket({
+     *   onReaction: (e) => console.log(`${e.emoji} from ${e.userAddress}`),
+     * });
+     * await sdk.authenticateStreamWebSocket();
+     * await sdk.subscribeToStream('mytoken');
+     *
+     * // Send a heart reaction at current stream position
+     * const currentTime = player.getCurrentTime(); // from MuxPlayer
+     * await sdk.sendStreamReaction('mytoken', '❤️', currentTime);
+     * ```
+     */
+    sendStreamReaction(tokenName: string, emoji: string, streamTime?: number): Promise<void>;
+    /**
+     * Send a typing indicator start event to a stream chat.
+     *
+     * Indicates that the authenticated user has started typing.
+     * The indicator auto-clears after 5 seconds of inactivity on the server.
+     * Use sendTypingStop() to explicitly stop the indicator.
+     *
+     * Requires:
+     * 1. WebSocket connected via connectStreamWebSocket()
+     * 2. Authenticated via authenticateStreamWebSocket()
+     * 3. Subscribed to the stream via subscribeToStream()
+     *
+     * @param tokenName - Token name for the stream chat room
+     * @throws ValidationError if WebSocket not connected or not authenticated
+     *
+     * @since 5.11.0
+     * @category WebSocket
+     *
+     * @example Send typing indicator
+     * ```typescript
+     * await sdk.connectStreamWebSocket({
+     *   onTypingIndicator: (e) => console.log(`${e.typingUsers.length} users typing`),
+     * });
+     * await sdk.authenticateStreamWebSocket();
+     * await sdk.subscribeToStream('mytoken');
+     *
+     * // User starts typing
+     * sdk.sendTypingStart('mytoken');
+     * ```
+     */
+    sendTypingStart(tokenName: string): void;
+    /**
+     * Send a typing indicator stop event to a stream chat.
+     *
+     * Indicates that the authenticated user has stopped typing.
+     * Call this when the user sends a message, clears the input, or blurs the input.
+     *
+     * Requires:
+     * 1. WebSocket connected via connectStreamWebSocket()
+     * 2. Authenticated via authenticateStreamWebSocket()
+     * 3. Subscribed to the stream via subscribeToStream()
+     *
+     * @param tokenName - Token name for the stream chat room
+     * @throws ValidationError if WebSocket not connected or not authenticated
+     *
+     * @since 5.11.0
+     * @category WebSocket
+     *
+     * @example Stop typing indicator after sending message
+     * ```typescript
+     * await sdk.sendStreamChatViaWebSocket('mytoken', message);
+     * sdk.sendTypingStop('mytoken');
+     * ```
+     */
+    sendTypingStop(tokenName: string): void;
+    /**
+     * Disconnect from the stream WebSocket server.
+     *
+     * Closes the WebSocket connection and cleans up resources.
+     *
+     * @since 5.1.0
+     * @category WebSocket
+     */
+    disconnectStreamWebSocket(): void;
+    /**
+     * Check if stream WebSocket is connected.
+     *
+     * @returns true if WebSocket is connected
+     *
+     * @since 5.1.0
+     * @category WebSocket
+     */
+    isStreamWebSocketConnected(): boolean;
+    /**
+     * Subscribe to stream status changes (online/offline)
+     *
+     * @param callback - Handler for stream status events
+     * @returns Unsubscribe function
+     *
+     * @since 5.12.0
+     * @category WebSocket
+     *
+     * @example
+     * ```typescript
+     * const unsubscribe = sdk.onStreamStatusChanged((event) => {
+     *   console.log(`${event.tokenName}: ${event.status}`);
+     * });
+     * ```
+     */
+    onStreamStatusChanged(callback: (event: import('./types/streaming-events.dto').StreamStatusChangedEvent) => void | Promise<void>): () => void;
+    /**
+     * Subscribe to user ban events
+     *
+     * @param callback - Handler for user banned events
+     * @returns Unsubscribe function
+     *
+     * @since 5.12.0
+     * @category WebSocket
+     */
+    onUserBanned(callback: (event: import('./types/streaming-events.dto').UserBannedEvent) => void | Promise<void>): () => void;
+    /**
+     * Subscribe to user unban events
+     *
+     * @param callback - Handler for user unbanned events
+     * @returns Unsubscribe function
+     *
+     * @since 5.12.0
+     * @category WebSocket
+     */
+    onUserUnbanned(callback: (event: import('./types/streaming-events.dto').UserUnbannedEvent) => void | Promise<void>): () => void;
+    /**
+     * Subscribe to ban enforcement events (kick, mute, ban)
+     *
+     * @param callback - Handler for ban enforcement events
+     * @returns Unsubscribe function
+     *
+     * @since 5.12.0
+     * @category WebSocket
+     */
+    onBanEnforcement(callback: (event: import('./types/streaming-events.dto').BanEnforcementEvent) => void | Promise<void>): () => void;
+    /**
+     * Subscribe to content flagged events (overseer)
+     *
+     * @param callback - Handler for content flagged events
+     * @returns Unsubscribe function
+     *
+     * @since 5.12.0
+     * @category WebSocket
+     */
+    onContentFlagged(callback: (event: import('./types/streaming-events.dto').ContentFlaggedEvent) => void | Promise<void>): () => void;
+    /**
+     * Subscribe to flag resolved events
+     *
+     * @param callback - Handler for flag resolved events
+     * @returns Unsubscribe function
+     *
+     * @since 5.12.0
+     * @category WebSocket
+     */
+    onFlagResolved(callback: (event: import('./types/streaming-events.dto').FlagResolvedEvent) => void | Promise<void>): () => void;
+    /**
+     * Subscribe to new stream chat messages
+     *
+     * @param callback - Handler for chat message events
+     * @returns Unsubscribe function
+     *
+     * @since 5.12.0
+     * @category WebSocket
+     */
+    onStreamChatMessage(callback: (event: import('./types/streaming-events.dto').StreamChatMessageEvent) => void | Promise<void>): () => void;
+    /**
+     * Subscribe to stream chat message updates
+     *
+     * @param callback - Handler for message updated events
+     * @returns Unsubscribe function
+     *
+     * @since 5.12.0
+     * @category WebSocket
+     */
+    onStreamChatUpdated(callback: (event: import('./types/streaming-events.dto').StreamChatUpdatedEvent) => void | Promise<void>): () => void;
+    /**
+     * Subscribe to stream chat message deletions
+     *
+     * @param callback - Handler for message deleted events
+     * @returns Unsubscribe function
+     *
+     * @since 5.12.0
+     * @category WebSocket
+     */
+    onStreamChatDeleted(callback: (event: import('./types/streaming-events.dto').StreamChatDeletedEvent) => void | Promise<void>): () => void;
+    /**
+     * Subscribe to stream chat message pins
+     *
+     * @param callback - Handler for message pinned events
+     * @returns Unsubscribe function
+     *
+     * @since 5.12.0
+     * @category WebSocket
+     */
+    onStreamChatPinned(callback: (event: import('./types/streaming-events.dto').StreamChatPinnedEvent) => void | Promise<void>): () => void;
+    /**
+     * Subscribe to stream chat message unpins
+     *
+     * @param callback - Handler for message unpinned events
+     * @returns Unsubscribe function
+     *
+     * @since 5.12.0
+     * @category WebSocket
+     */
+    onStreamChatUnpinned(callback: (event: import('./types/streaming-events.dto').StreamChatUnpinnedEvent) => void | Promise<void>): () => void;
+    /**
+     * Subscribe to chat status changes (enable/disable)
+     *
+     * @param callback - Handler for chat status events
+     * @returns Unsubscribe function
+     *
+     * @since 5.12.0
+     * @category WebSocket
+     */
+    onChatStatusChanged(callback: (event: import('./types/streaming-events.dto').ChatStatusChangedEvent) => void | Promise<void>): () => void;
+    /**
+     * Subscribe to viewer count changes
+     *
+     * @param callback - Handler for viewer count events
+     * @returns Unsubscribe function
+     *
+     * @since 5.12.0
+     * @category WebSocket
+     */
+    onViewerCountChanged(callback: (event: import('./types/streaming-events.dto').ViewerCountChangedEvent) => void | Promise<void>): () => void;
+    /**
+     * Subscribe to recording status changes
+     *
+     * @param callback - Handler for recording status events
+     * @returns Unsubscribe function
+     *
+     * @since 5.12.0
+     * @category WebSocket
+     */
+    onRecordingStatusChanged(callback: (event: import('./types/streaming-events.dto').RecordingStatusChangedEvent) => void | Promise<void>): () => void;
+    /**
+     * Subscribe to simulcast target status changes
+     *
+     * @param callback - Handler for simulcast status events
+     * @returns Unsubscribe function
+     *
+     * @since 5.12.0
+     * @category WebSocket
+     */
+    onSimulcastStatusChanged(callback: (event: import('./types/streaming-events.dto').SimulcastStatusChangedEvent) => void | Promise<void>): () => void;
+    /**
+     * Subscribe to download ready events
+     *
+     * @param callback - Handler for download ready events
+     * @returns Unsubscribe function
+     *
+     * @since 5.12.0
+     * @category WebSocket
+     */
+    onDownloadReady(callback: (event: import('./types/streaming-events.dto').DownloadReadyEvent) => void | Promise<void>): () => void;
+    /**
+     * Subscribe to user typing indicators
+     *
+     * @param callback - Handler for user typing events
+     * @returns Unsubscribe function
+     *
+     * @since 5.12.0
+     * @category WebSocket
+     */
+    onUserTyping(callback: (event: import('./types/streaming-events.dto').UserTypingEvent) => void | Promise<void>): () => void;
+    /**
+     * Subscribe to stream reactions (emoji)
+     *
+     * @param callback - Handler for stream reaction events
+     * @returns Unsubscribe function
+     *
+     * @since 5.12.0
+     * @category WebSocket
+     */
+    onStreamReaction(callback: (event: import('./types/streaming-events.dto').StreamReactionEvent) => void | Promise<void>): () => void;
+    /**
+     * Subscribe to content reaction additions
+     *
+     * @param callback - Handler for content reaction added events
+     * @returns Unsubscribe function
+     *
+     * @since 5.12.0
+     * @category WebSocket
+     */
+    onContentReactionAdded(callback: (event: import('./types/streaming-events.dto').ContentReactionAddedEvent) => void | Promise<void>): () => void;
+    /**
+     * Subscribe to content reaction removals
+     *
+     * @param callback - Handler for content reaction removed events
+     * @returns Unsubscribe function
+     *
+     * @since 5.12.0
+     * @category WebSocket
+     */
+    onContentReactionRemoved(callback: (event: import('./types/streaming-events.dto').ContentReactionRemovedEvent) => void | Promise<void>): () => void;
+    /**
+     * Subscribe to stream countdown updates
+     *
+     * @param callback - Handler for countdown updated events
+     * @returns Unsubscribe function
+     *
+     * @since 5.12.0
+     * @category WebSocket
+     */
+    onStreamCountdownUpdated(callback: (event: import('./types/streaming-events.dto').StreamCountdownUpdatedEvent) => void | Promise<void>): () => void;
+    /**
+     * Subscribe to stream language updates
+     *
+     * @param callback - Handler for language updated events
+     * @returns Unsubscribe function
+     *
+     * @since 5.12.0
+     * @category WebSocket
+     */
+    onStreamLanguageUpdated(callback: (event: import('./types/streaming-events.dto').StreamLanguageUpdatedEvent) => void | Promise<void>): () => void;
+    /**
+     * Subscribe to stream control status changes
+     *
+     * @param callback - Handler for control status changed events
+     * @returns Unsubscribe function
+     *
+     * @since 5.12.0
+     * @category WebSocket
+     */
+    onStreamControlStatusChanged(callback: (event: import('./types/streaming-events.dto').StreamControlStatusChangedEvent) => void | Promise<void>): () => void;
+    /**
+     * Subscribe to WebSocket connection events
+     *
+     * @param callback - Handler for connection events
+     * @returns Unsubscribe function
+     *
+     * @since 5.12.0
+     * @category WebSocket
+     */
+    onConnection(callback: (event: import('./types/streaming-events.dto').ConnectionEvent) => void | Promise<void>): () => void;
+    /**
+     * Subscribe to WebSocket authentication events
+     *
+     * @param callback - Handler for authenticated events
+     * @returns Unsubscribe function
+     *
+     * @since 5.12.0
+     * @category WebSocket
+     */
+    onAuthenticated(callback: (event: import('./types/streaming-events.dto').AuthenticatedEvent) => void | Promise<void>): () => void;
+    /**
+     * Subscribe to token stream room subscription events
+     *
+     * @param callback - Handler for token subscribed events
+     * @returns Unsubscribe function
+     *
+     * @since 5.12.0
+     * @category WebSocket
+     */
+    onTokenSubscribed(callback: (event: import('./types/streaming-events.dto').TokenSubscribedEvent) => void | Promise<void>): () => void;
+    /**
+     * Subscribe to token stream room unsubscription events
+     *
+     * @param callback - Handler for token unsubscribed events
+     * @returns Unsubscribe function
+     *
+     * @since 5.12.0
+     * @category WebSocket
+     */
+    onTokenUnsubscribed(callback: (event: import('./types/streaming-events.dto').TokenUnsubscribedEvent) => void | Promise<void>): () => void;
+    /**
+     * Subscribe to comment room subscription events
+     *
+     * @param callback - Handler for room subscribed events
+     * @returns Unsubscribe function
+     *
+     * @since 5.12.0
+     * @category WebSocket
+     */
+    onRoomSubscribed(callback: (event: import('./types/streaming-events.dto').RoomSubscribedEvent) => void | Promise<void>): () => void;
+    /**
+     * Subscribe to comment room unsubscription events
+     *
+     * @param callback - Handler for room left events
+     * @returns Unsubscribe function
+     *
+     * @since 5.12.0
+     * @category WebSocket
+     */
+    onRoomLeft(callback: (event: import('./types/streaming-events.dto').RoomLeftEvent) => void | Promise<void>): () => void;
+    /**
+     * Estimate bridge fees for a cross-chain transfer.
+     *
+     * Calculates the expected fees for bridging tokens from GalaChain to an
+     * external chain (Ethereum or Solana).
+     *
+     * @param params - Fee estimation parameters
+     * @returns Promise resolving to fee estimate with breakdown
+     * @throws Error if wallet is not configured
+     * @throws Error if token is not bridgeable to the destination chain
+     *
+     * @since 4.0.16
+     * @category Bridge
+     *
+     * @example Estimate fee for bridging GALA to Ethereum
+     * ```typescript
+     * const fee = await sdk.estimateBridgeFee({
+     *   tokenId: 'GALA|Unit|none|none',
+     *   destinationChain: 'Ethereum',
+     *   amount: '100',
+     * });
+     * console.log(`Fee: ${fee.totalFee} GALA`);
+     * ```
+     */
+    estimateBridgeFee(params: EstimateBridgeFeeParams): Promise<BridgeFeeEstimate>;
+    /**
+     * Bridge tokens from GalaChain to an external chain.
+     *
+     * Initiates a cross-chain transfer from GalaChain to Ethereum or Solana.
+     * The transfer will lock tokens on GalaChain and mint wrapped tokens on
+     * the destination chain.
+     *
+     * @param params - Bridge out parameters
+     * @returns Promise resolving to transaction details
+     * @throws Error if wallet is not configured
+     * @throws Error if token is not bridgeable to the destination chain
+     * @throws Error if recipient address is invalid
+     *
+     * @since 4.0.16
+     * @category Bridge
+     *
+     * @example Bridge GALA to Ethereum
+     * ```typescript
+     * const result = await sdk.bridgeOut({
+     *   tokenId: 'GALA|Unit|none|none',
+     *   amount: '100',
+     *   destinationChain: 'Ethereum',
+     *   recipientAddress: '0x1234...abcd',
+     * });
+     * console.log(`Transaction: ${result.transactionHash}`);
+     * ```
+     */
+    bridgeOut(params: BridgeOutParams): Promise<BridgeTransaction>;
+    /**
+     * Bridge tokens from an external chain to GalaChain.
+     *
+     * Initiates a cross-chain transfer from Ethereum or Solana to GalaChain.
+     * The transfer will burn wrapped tokens on the source chain and unlock
+     * tokens on GalaChain.
+     *
+     * @param params - Bridge in parameters
+     * @returns Promise resolving to transaction details
+     * @throws Error if wallet is not configured
+     * @throws Error if token is not bridgeable from the source chain
+     *
+     * @since 4.0.16
+     * @category Bridge
+     *
+     * @example Bridge GALA from Ethereum to GalaChain
+     * ```typescript
+     * const result = await sdk.bridgeIn({
+     *   tokenId: 'GALA|Unit|none|none',
+     *   amount: '100',
+     *   sourceChain: 'Ethereum',
+     * });
+     * console.log(`Transaction: ${result.transactionHash}`);
+     * ```
+     */
+    bridgeIn(params: BridgeInParams): Promise<BridgeTransaction>;
+    /**
+     * Get the status of a bridge transaction.
+     *
+     * Checks the current status of a cross-chain bridge transaction.
+     *
+     * @param transactionHash - Transaction hash to check
+     * @param chainHint - Optional chain hint for faster lookup
+     * @returns Promise resolving to bridge status
+     *
+     * @since 4.0.16
+     * @category Bridge
+     *
+     * @example Check bridge status
+     * ```typescript
+     * const status = await sdk.getBridgeStatus(
+     *   '0x1234...abcd',
+     *   'Ethereum'
+     * );
+     * console.log(`Status: ${status.status}`);
+     * ```
+     */
+    getBridgeStatus(transactionHash: string, chainHint?: 'Ethereum' | 'Solana'): Promise<BridgeStatus>;
+    /**
+     * Get list of tokens supported for bridging.
+     *
+     * Returns the static list of tokens that can be bridged between
+     * GalaChain and external chains.
+     *
+     * @returns Promise resolving to supported bridge tokens
+     *
+     * @since 4.0.16
+     * @category Bridge
+     *
+     * @example Get supported tokens
+     * ```typescript
+     * const tokens = await sdk.getSupportedBridgeTokens();
+     * tokens.tokens.forEach(t => {
+     *   console.log(`${t.symbol}: ${t.supportedChains.join(', ')}`);
+     * });
+     * ```
+     */
+    getSupportedBridgeTokens(): Promise<{
+        tokens: BridgeToken[];
+        totalCount: number;
+        supportedChains: string[];
+    }>;
+    /**
+     * Fetch token balance from GalaChain (published tokens) or DEX API (launchpad tokens)
+     *
+     * This method queries either the GalaChain gateway directly for published tokens
+     * or the DEX API for launchpad tokens, providing reliable results.
+     *
+     * @param options Token balance options with flexible token identification
+     * @returns Promise<TokenBalanceResult | null>
+     *
+     * @example
+     * ```typescript
+     * // Using string format
+     * const galaBalance = await sdk.fetchTokenBalance({
+     *   address: sdk.getAddress(),
+     *   tokenId: "GALA|Unit|none|none"
+     * });
+     *
+     * // Using TokenClassKey object
+     * const tokenClass = await sdk.resolveTokenClassKey('unicorn');
+     * const unicornBalance = await sdk.fetchTokenBalance({
+     *   address: sdk.getAddress(),
+     *   tokenClassKey: tokenClass
+     * });
+     *
+     * // Using TokenInstanceKey object
+     * const unicornBalance2 = await sdk.fetchTokenBalance({
+     *   address: sdk.getAddress(),
+     *   tokenId: {
+     *     collection: "Token",
+     *     category: "Unit",
+     *     type: "UNI",
+     *     additionalKey: "eth:9401b171307bE656f00F9e18DF756643FD3a91dE",
+     *     instance: "0"
+     *   }
+     * });
+     *
+     * // Using token name for convenience
+     * const unicornBalance3 = await sdk.fetchTokenBalance({
+     *   address: sdk.getAddress(),
+     *   tokenName: "unicorn"
+     * });
+     * ```
+     */
+    fetchTokenBalance(options: FetchTokenBalanceOptions): Promise<import("./types/user.dto").TokenBalanceResult | {
+        quantity: unknown;
+        collection: string;
+        category: string;
+        tokenId: string;
+        symbol: string;
+        name: string;
+    } | null>;
+    /**
+     * Fetch only locked balance for a token
+     *
+     * Returns focused information about locked tokens including lock details.
+     * Requires tokenId (not tokenName) as lock details are only available from GalaChain.
+     *
+     * @param options Balance query options (must include tokenId, not tokenName)
+     * @returns Promise<LockedBalanceResult | null> Locked balance details or null if no balance
+     * @throws Error if tokenName is provided (lock details require tokenId)
+     *
+     * @example
      * ```typescript
      * const locked = await sdk.fetchLockedBalance({
      *   address: sdk.getAddress(),
@@ -3261,6 +6271,56 @@ export declare class LaunchpadSDK {
      * ```
      */
     uploadTokenImage(options: UploadImageByTokenNameOptions): Promise<string>;
+    /**
+     * Updates token social media links (v6.x.0+)
+     *
+     * Requires JWT authentication (pool owner only).
+     * Updates the social media URLs for a token pool.
+     *
+     * @category Token Management
+     * @param options Update options containing tokenName and social URLs
+     * @returns Updated token metadata with social links
+     * @throws {ValidationError} If token name is invalid
+     * @throws {ConfigurationError} If JWT auth is not configured
+     * @throws {Error} If user is not authorized to update this token
+     * @since 6.x.0
+     *
+     * @example Update token socials
+     * ```typescript
+     * const result = await sdk.updateTokenSocials({
+     *   tokenName: 'mytoken',
+     *   websiteUrl: 'https://example.com',
+     *   twitterUrl: 'https://twitter.com/example',
+     *   telegramUrl: 'https://t.me/example',
+     * });
+     * console.log('Updated socials:', result);
+     * ```
+     */
+    updateTokenSocials(options: UpdateSocialLinksDto): Promise<UpdateSocialLinksResponse>;
+    /**
+     * Checks if a pool exists (v6.x.0+)
+     *
+     * Convenience method that checks pool existence by token name or symbol.
+     * At least one parameter is required.
+     *
+     * @category Token Validation
+     * @param tokenName Optional token name to check
+     * @param symbol Optional token symbol to check
+     * @returns Promise<boolean> True if pool exists, false otherwise
+     * @throws {ValidationError} If neither parameter is provided
+     * @since 6.x.0
+     *
+     * @example Check pool existence
+     * ```typescript
+     * const exists = await sdk.checkPoolExists('mytoken');
+     * console.log('Pool exists:', exists);
+     *
+     * // Or check by symbol
+     * const existsBySymbol = await sdk.checkPoolExists(undefined, 'MT');
+     * console.log('Pool with symbol MT exists:', existsBySymbol);
+     * ```
+     */
+    checkPoolExists(tokenName?: string, symbol?: string): Promise<boolean>;
     /**
      * Check if a token name is available for use
      *
@@ -3711,6 +6771,48 @@ export declare class LaunchpadSDK {
      * - Passing both parameters together is discouraged (tokenName takes precedence)
      */
     fetchTokensCreated(options?: FetchTokensCreatedOptions): Promise<import("./types/user.dto").UserTokenListResult>;
+    /**
+     * Get all tokens the authenticated user can manage.
+     *
+     * Returns a comprehensive view of the user's management capabilities:
+     * - **ownedTokens**: Tokens the user created (full OWNER access)
+     * - **moderatedTokens**: Tokens with moderator access via claimed invites
+     * - **isOverseer**: Whether user has platform-wide overseer access
+     * - **overseerSince**: When user became overseer (if applicable)
+     *
+     * This is used by the /moderators dashboard page to show all tokens
+     * a user can access in Studio.
+     *
+     * **Requires JWT authentication** - call sdk.login() before using this method.
+     *
+     * @param options Optional pagination options (page, limit)
+     * @returns Promise resolving to managed tokens result
+     * @throws ConfigurationError if JWT auth is not configured
+     * @throws ValidationError if pagination parameters are invalid
+     *
+     * @since 5.11.0
+     * @category User
+     *
+     * @example Get all managed tokens
+     * ```typescript
+     * const managed = await sdk.getManagedTokens();
+     *
+     * console.log(`Owned tokens: ${managed.ownedTokensCount}`);
+     * console.log(`Moderated tokens: ${managed.moderatedTokensCount}`);
+     * console.log(`Is overseer: ${managed.isOverseer}`);
+     *
+     * // List owned tokens with Studio links
+     * managed.ownedTokens.forEach(token => {
+     *   console.log(`${token.tokenName} - ${token.isLive ? 'LIVE' : 'offline'}`);
+     * });
+     *
+     * // List moderated tokens with role info
+     * managed.moderatedTokens.forEach(token => {
+     *   console.log(`${token.tokenName} - ${token.role} (${token.inviteScope})`);
+     * });
+     * ```
+     */
+    getManagedTokens(options?: GetManagedTokensOptions): Promise<ManagedTokensResult>;
     /**
      * Fetch historical price data for DEX tokens via DEX Backend API
      *
@@ -4130,22 +7232,6 @@ export declare class LaunchpadSDK {
      * - Returns quote with estimated output, fee tier, and price impact
      * - Automatically selects optimal liquidity pool for best pricing
      *
-     * Phase 2 Migration Plan:
-     * This method will be migrated to eliminate GSwap SDK dependency by:
-     * 1. Implementing quote calculation directly in BundlerService
-     * 2. Fetching pool state directly from GalaChain (Slot0, liquidity, ticks)
-     * 3. Implementing Uniswap V3 quote algorithm locally
-     * 4. Adding intelligent route finding for multi-hop swaps
-     * 5. Adding quote result caching for performance
-     * 6. Maintaining backward-compatible API while removing SDK dependency
-     *
-     * Benefits of Phase 2 Migration:
-     * - Eliminates external GSwap SDK dependency
-     * - Enables offline quote calculations
-     * - Adds quote caching for repeated queries
-     * - Better control over quote accuracy and staleness
-     * - Foundation for more advanced routing strategies
-     *
      * @category DEX Trading
      * @param fromToken Source token in pipe-delimited format (e.g., "GALA|Unit|none|none")
      * @param toToken Destination token in pipe-delimited format (e.g., "GUSDC|Unit|none|none")
@@ -4176,22 +7262,6 @@ export declare class LaunchpadSDK {
      * - Returns quote with required input, fee tier, and price impact
      * - Ensures amount constraints are satisfied with slippage buffer
      *
-     * Phase 2 Migration Plan:
-     * This method will be migrated to eliminate GSwap SDK dependency by:
-     * 1. Implementing quote calculation directly in BundlerService
-     * 2. Fetching pool state directly from GalaChain (Slot0, liquidity, ticks)
-     * 3. Implementing reverse Uniswap V3 quote algorithm locally
-     * 4. Adding intelligent route finding for multi-hop swaps
-     * 5. Adding quote result caching for performance
-     * 6. Maintaining backward-compatible API while removing SDK dependency
-     *
-     * Benefits of Phase 2 Migration:
-     * - Eliminates external GSwap SDK dependency
-     * - Enables offline quote calculations
-     * - Adds quote caching for repeated queries
-     * - Better control over quote accuracy and staleness
-     * - Foundation for more advanced routing strategies
-     *
      * @category DEX Trading
      * @param fromToken Source token in pipe-delimited format (e.g., "GALA|Unit|none|none")
      * @param toToken Destination token in pipe-delimited format (e.g., "GUSDC|Unit|none|none")
@@ -4638,7 +7708,7 @@ export declare class LaunchpadSDK {
         tickLower: number;
         tickUpper: number;
         owner: string;
-    }): Promise<import("./types/gswap-responses.types").GSwapEstimateRemoveLiquidityResult>;
+    }): Promise<import(".").GSwapEstimateRemoveLiquidityResult>;
     /**
      * Add liquidity using price range
      *
@@ -4675,7 +7745,7 @@ export declare class LaunchpadSDK {
      * console.log(`Position created: ${result.positionId}`);
      * ```
      */
-    addSwapLiquidityByPrice(args: AddLiquidityByPriceArgs): Promise<import("./types/gswap-responses.types").GSwapAddLiquidityResult & {
+    addSwapLiquidityByPrice(args: AddLiquidityByPriceArgs): Promise<import(".").GSwapAddLiquidityResult & {
         timestamp?: Date;
         wait?: (timeoutMs?: number) => Promise<void>;
     }>;
@@ -4712,7 +7782,7 @@ export declare class LaunchpadSDK {
      * console.log(`Position created: ${result.positionId}`);
      * ```
      */
-    addSwapLiquidityByTicks(args: AddLiquidityByTicksArgs): Promise<import("./types/gswap-responses.types").GSwapAddLiquidityResult & {
+    addSwapLiquidityByTicks(args: AddLiquidityByTicksArgs): Promise<import(".").GSwapAddLiquidityResult & {
         timestamp?: Date;
         wait?: (timeoutMs?: number) => Promise<void>;
     }>;
@@ -4767,7 +7837,7 @@ export declare class LaunchpadSDK {
      * });
      * ```
      */
-    removeSwapLiquidity(args: RemoveLiquidityArgs): Promise<import("./types/gswap-responses.types").GSwapAddLiquidityResult>;
+    removeSwapLiquidity(args: RemoveLiquidityArgs): Promise<import(".").GSwapAddLiquidityResult>;
     /**
      * Collect accumulated position fees
      *
@@ -4791,7 +7861,7 @@ export declare class LaunchpadSDK {
      * console.log(`Collected: ${result.amount0} token0, ${result.amount1} token1`);
      * ```
      */
-    collectSwapPositionFees(args: CollectFeesArgs): Promise<import("./types/gswap-responses.types").GSwapAddLiquidityResult>;
+    collectSwapPositionFees(args: CollectFeesArgs): Promise<import(".").GSwapAddLiquidityResult>;
     /**
      * Connect to WebSocket for real-time events
      *
@@ -5191,6 +8261,10 @@ export declare class LaunchpadSDK {
         websiteUrl: string;
         telegramUrl: string;
         twitterUrl: string;
+        instagramUrl: string;
+        facebookUrl: string;
+        redditUrl: string;
+        tiktokUrl: string;
         isFinalized: boolean;
     }) => void, options?: {
         creatorFilter?: string;