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

package/dist/services/BundleService.d.ts

@@ -0,0 +1,245 @@
+/**
+ * Bundle Service for Transaction Processing
+ *
+ * This service handles bundle transaction submission to the launchpad
+ * backend. It formats the request data in the exact structure expected
+ * by the bundle API and provides proper error handling.
+ *
+ * ## Bundle Transaction Format:
+ * ```json
+ * {
+ *   "signedDto": {
+ *     // Signed DTO with signature, types, domain
+ *   },
+ *   "stringsInstructions": [
+ *     // Array of resource tracking strings
+ *   ],
+ *   "method": "BuyWithNative" | "BuyExactToken" | "SellExactToken" | "SellWithNative"
+ * }
+ * ```
+ *
+ * ## Response Handling:
+ * - Success: Returns transaction ID for WebSocket monitoring
+ * - Error: Provides detailed error messages for debugging
+ *
+ * @category Services
+ * @since 2.0.0
+ */
+import type { ApiResponse } from '../types/common';
+import type { BuyTokenOptions, SellTokenOptions } from '../types/options.dto';
+import type { EIP712Domain, EIP712Types } from '../types/trade.dto';
+import type { HttpClient } from '../utils/http';
+import { BaseService } from './BaseService';
+import type { TokenResolverService } from './TokenResolverService';
+/**
+ * Signed DTO structure with EIP-712 signature
+ *
+ * Note: types and domain are optional to support TrustWallet which uses signMessage
+ * instead of signTypedData and doesn't include these fields in the payload.
+ */
+export interface SignedDto {
+    signature: string;
+    types?: EIP712Types;
+    domain?: EIP712Domain;
+    [key: string]: unknown;
+}
+/**
+ * Bundle transaction data structure
+ */
+export interface BundleTransactionData {
+    signedDto: SignedDto;
+    stringsInstructions: string[];
+    method: string;
+}
+/**
+ * Service for handling bundle transaction submission and trading operations
+ */
+export declare class BundleService extends BaseService {
+    private tokenResolver;
+    private _walletProvider?;
+    private userAddress?;
+    private defaultSlippageToleranceFactor;
+    private defaultMaxAcceptableReverseBondingCurveFeeSlippageFactor;
+    private readonly bundleEndpoint;
+    private signatureService?;
+    private tokenKeyService?;
+    constructor(httpClient: HttpClient, tokenResolver: TokenResolverService, debugMode?: boolean, _walletProvider?: unknown | undefined, userAddress?: string | undefined, defaultSlippageToleranceFactor?: number, defaultMaxAcceptableReverseBondingCurveFeeSlippageFactor?: number);
+    /**
+     * Submit a bundle transaction to the backend
+     *
+     * @param bundleData - Complete bundle transaction data
+     * @returns API response with transaction ID or error
+     *
+     * @example
+     * ```typescript
+     * const bundleData = {
+     *   signedDto: signedPayload,
+     *   stringsInstructions: [
+     *     '$service$Token$Unit$ANIME$none$launchpad',
+     *     '$tokenBalance$Token$Unit$ANIME$none$vaultAddress',
+     *     // ... more strings
+     *   ],
+     *   method: 'BuyWithNative'
+     * };
+     *
+     * const response = await bundleService.submitTransaction(bundleData);
+     * ```
+     */
+    submitTransaction(bundleData: BundleTransactionData): Promise<ApiResponse>;
+    /**
+     * Validate bundle transaction data
+     */
+    private validateBundleData;
+    /**
+     * Format bundle request for API submission
+     */
+    private formatBundleRequest;
+    /**
+     * Handle bundle API response
+     */
+    private handleBundleResponse;
+    /**
+     * Format error message for consistent error handling
+     */
+    private formatErrorMessage;
+    /**
+     * Get bundle transaction result
+     *
+     * Returns a lightweight status check for a bundle transaction via HTTP (not WebSocket).
+     * Response format: `{ id: string, method: string, status: string }`
+     *
+     * @param transactionId - Transaction ID returned from submitTransaction
+     * @returns Transaction result with id, method, and status (COMPLETED, FAILED, PENDING, PROCESSING)
+     *
+     * @example
+     * ```typescript
+     * const result = await bundleService.getBundlerTransactionResult('3c7d9f79-a496-4794-abaf-d6bd13473ff7');
+     * console.log(result.data.status); // "FAILED", "COMPLETED", etc.
+     * ```
+     */
+    getBundlerTransactionResult(transactionId: string): Promise<ApiResponse>;
+    /**
+     * Cancel a pending bundle transaction
+     *
+     * @param transactionId - Transaction ID to cancel
+     * @returns Cancellation result
+     */
+    cancelTransaction(transactionId: string): Promise<ApiResponse>;
+    /**
+     * Get bundle service health status
+     *
+     * @returns Service health information
+     */
+    getHealthStatus(): Promise<ApiResponse>;
+    /**
+     * Buy tokens with unified, simplified API
+     *
+     * @param options Trading options
+     * @param options.tokenName Token name (e.g., "dragnrkti", "rocketri", "unicornri")
+     * @param options.amount Amount to trade (GALA for 'native', tokens for 'exact')
+     * @param options.type Trading type: 'native' = spend GALA, 'exact' = buy exact tokens
+     * @param options.expectedAmount Expected amount from prior calculation (required)
+     * @param options.slippageToleranceFactor Optional slippage tolerance factor (default: SDK default)
+     * @returns Promise<ApiResponse> Transaction result
+     * @throws ValidationError if parameters are invalid or token not found
+     *
+     * @example
+     * ```typescript
+     * // Buy tokens by spending exactly 100 GALA
+     * const result = await bundleService.buyToken({
+     *   tokenName: "dragnrkti",
+     *   amount: "100",
+     *   type: "native",
+     *   expectedAmount: "1342612.26",
+     *   slippageToleranceFactor: 0.05
+     * });
+     *
+     * // Buy exactly 50 tokens
+     * const result = await bundleService.buyToken({
+     *   tokenName: "dragnrkti",
+     *   amount: "50",
+     *   type: "exact",
+     *   expectedAmount: "3.75",
+     *   slippageToleranceFactor: 0.03
+     * });
+     * ```
+     */
+    buyToken(options: BuyTokenOptions): Promise<ApiResponse>;
+    /**
+     * Sell tokens with unified, simplified API
+     *
+     * @param options Trading options
+     * @param options.tokenName Token name (e.g., "dragnrkti", "rocketri", "unicornri")
+     * @param options.amount Amount to trade (tokens for 'exact', GALA for 'native')
+     * @param options.type Trading type: 'exact' = sell exact tokens, 'native' = receive exact GALA
+     * @param options.expectedAmount Expected amount from prior calculation (required)
+     * @param options.maxAcceptableReverseBondingCurveFee Optional max acceptable reverse bonding curve fee
+     * @param options.slippageToleranceFactor Optional slippage tolerance factor (default: SDK default)
+     * @returns Promise<ApiResponse> Transaction result
+     * @throws ValidationError if parameters are invalid or token not found
+     *
+     * @example
+     * ```typescript
+     * // Sell exactly 50 tokens (with slippage protection)
+     * const result = await bundleService.sellToken({
+     *   tokenName: "dragnrkti",
+     *   amount: "50",
+     *   type: "exact",
+     *   expectedAmount: "3.75",
+     *   slippageToleranceFactor: 0.05
+     * });
+     *
+     * // Sell tokens to receive exactly 25 GALA (with slippage protection)
+     * const result = await bundleService.sellToken({
+     *   tokenName: "dragnrkti",
+     *   amount: "25",
+     *   type: "native",
+     *   expectedAmount: "333.33",
+     *   slippageToleranceFactor: 0.03
+     * });
+     * ```
+     */
+    sellToken(options: SellTokenOptions): Promise<ApiResponse>;
+    /**
+     * Prepare trading operation: calculate slippage and resolve vault address
+     *
+     * Consolidates the common preparation logic used by both buyToken and sellToken.
+     * Eliminates code duplication in trading setup.
+     *
+     * @param tokenName Token name to resolve
+     * @param maxAcceptableReverseBondingCurveFee Base max acceptable fee
+     * @param maxAcceptableReverseBondingCurveFeeSlippageFactor Fee slippage override
+     * @param slippageToleranceFactor Amount slippage override
+     * @returns Prepared trading parameters
+     * @throws Error if token not found
+     * @private
+     */
+    private prepareTradingOperation;
+    /**
+     * Calculate effective slippage factors and max fee with slippage protection
+     *
+     * Centralizes the slippage calculation logic used by both buyToken and sellToken methods.
+     *
+     * @param maxAcceptableReverseBondingCurveFee - Base max acceptable fee
+     * @param maxAcceptableReverseBondingCurveFeeSlippageFactor - Fee slippage override
+     * @param slippageToleranceFactor - Amount slippage override
+     * @returns Effective factors and adjusted max fee
+     */
+    private calculateEffectiveSlippage;
+    /**
+     * Ensure trading services are available
+     */
+    private ensureTradingServicesAvailable;
+    /**
+     * Execute bundle transaction with signature generation
+     */
+    private executeBundleTransaction;
+    /**
+     * Resolves a token name to its vault address using TokenResolverService
+     *
+     * @param tokenName Token name to resolve (e.g., 'dragnrkti', 'rocketri')
+     * @returns Promise<string | null> Vault address if found, null otherwise
+     */
+    private resolveTokenNameToVault;
+}
+//# sourceMappingURL=BundleService.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"BundleService.d.ts","sourceRoot":"","sources":["../../src/services/BundleService.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAcH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AACnD,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAC9E,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAIpE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAKhD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAK5C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAEnE;;;;;GAKG;AACH,MAAM,WAAW,SAAS;IACxB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,WAAW,CAAC;IACpB,MAAM,CAAC,EAAE,YAAY,CAAC;IACtB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,SAAS,EAAE,SAAS,CAAC;IACrB,mBAAmB,EAAE,MAAM,EAAE,CAAC;IAC9B,MAAM,EAAE,MAAM,CAAC;CAChB;AAYD;;GAEG;AACH,qBAAa,aAAc,SAAQ,WAAW;IAO1C,OAAO,CAAC,aAAa;IAErB,OAAO,CAAC,eAAe,CAAC;IACxB,OAAO,CAAC,WAAW,CAAC;IACpB,OAAO,CAAC,8BAA8B;IACtC,OAAO,CAAC,wDAAwD;IAXlE,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAa;IAC5C,OAAO,CAAC,gBAAgB,CAAC,CAAmB;IAC5C,OAAO,CAAC,eAAe,CAAC,CAAuB;gBAG7C,UAAU,EAAE,UAAU,EACd,aAAa,EAAE,oBAAoB,EAC3C,SAAS,GAAE,OAAe,EAClB,eAAe,CAAC,EAAE,OAAO,YAAA,EACzB,WAAW,CAAC,EAAE,MAAM,YAAA,EACpB,8BAA8B,GAAE,MAAa,EAC7C,wDAAwD,GAAE,MAAa;IAajF;;;;;;;;;;;;;;;;;;;;OAoBG;IACG,iBAAiB,CACrB,UAAU,EAAE,qBAAqB,GAChC,OAAO,CAAC,WAAW,CAAC;IAiEvB;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAiE1B;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAQ3B;;OAEG;IACH,OAAO,CAAC,oBAAoB;IA4B5B;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAyB1B;;;;;;;;;;;;;;OAcG;IACG,2BAA2B,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC;IAkD9E;;;;;OAKG;IACG,iBAAiB,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC;IAkDpE;;;;OAIG;IACG,eAAe,IAAI,OAAO,CAAC,WAAW,CAAC;IAqC7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;IACG,QAAQ,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,WAAW,CAAC;IAmG9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;IACG,SAAS,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,WAAW,CAAC;IAqGhE;;;;;;;;;;;;;OAaG;YACW,uBAAuB;IA+BrC;;;;;;;;;OASG;IACH,OAAO,CAAC,0BAA0B;IAuClC;;OAEG;IACH,OAAO,CAAC,8BAA8B;IActC;;OAEG;YACW,wBAAwB;IAmEtC;;;;;OAKG;YAEW,uBAAuB;CAKtC"}

package/dist/services/BundlerClientFactory.d.ts

@@ -0,0 +1,32 @@
+/**
+ * BundlerClientFactory - Factory for creating Bundler API HTTP clients
+ *
+ * Centralizes the creation of HTTP clients for communication with the GalaChain Bundler service.
+ * Ensures consistent configuration (timeout, headers) across all bundler operations.
+ *
+ * @since 5.16.0
+ */
+import type { AxiosInstance } from 'axios';
+/**
+ * Factory for creating Bundler API HTTP clients with consistent configuration
+ */
+export declare class BundlerClientFactory {
+    /**
+     * Create a new Bundler API HTTP client with standard configuration
+     *
+     * @param baseUrl Base URL for the Bundler API (e.g., "https://bundler.api.galachain.com")
+     * @param timeout Request timeout in milliseconds (default: 60000)
+     * @returns Configured AxiosInstance for Bundler API calls
+     *
+     * @example
+     * ```typescript
+     * const bundlerClient = BundlerClientFactory.createClient(
+     *   'https://bundler.api.galachain.com',
+     *   60000
+     * );
+     * const response = await bundlerClient.post('/bundle', { transactions: [...] });
+     * ```
+     */
+    static createClient(baseUrl: string, timeout?: number): AxiosInstance;
+}
+//# sourceMappingURL=BundlerClientFactory.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"BundlerClientFactory.d.ts","sourceRoot":"","sources":["../../src/services/BundlerClientFactory.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAI3C;;GAEG;AACH,qBAAa,oBAAoB;IAC/B;;;;;;;;;;;;;;;OAeG;IACH,MAAM,CAAC,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,SAAQ,GAAG,aAAa;CAGrE"}

package/dist/services/ChartService.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Chart Service
+ *
+ * Handles fetching historical chart/candlestick data for tokens.
+ *
+ * @category Services
+ * @since 7.2.0
+ */
+import type { HttpClient } from '../utils/http';
+import { BaseService } from './BaseService';
+/**
+ * Chart data point with OHLC data
+ */
+export interface ChartDataPoint {
+    /** Timestamp (Unix seconds) */
+    startTime: number;
+    /** Opening price */
+    openPrice: string;
+    /** Closing price */
+    closePrice: string;
+    /** Lowest price in period */
+    lowPrice: string;
+    /** Highest price in period */
+    highPrice: string;
+    /** Volume in period */
+    volume: string;
+}
+/**
+ * Chart request options
+ */
+export interface GetChartOptions {
+    /** Token name to get chart for */
+    tokenName: string;
+    /** Start timestamp (Unix seconds) */
+    from: number;
+    /** End timestamp (Unix seconds) */
+    to: number;
+    /** Data resolution interval in seconds */
+    resolution: number;
+}
+/**
+ * Chart result
+ */
+export interface ChartResult {
+    /** Array of candlestick data points */
+    dataPoints: ChartDataPoint[];
+    /** Whether chart data is available */
+    isPreviousData?: boolean;
+}
+/**
+ * Chart Service Class
+ *
+ * Provides methods for fetching historical chart data.
+ *
+ * @example
+ * ```typescript
+ * const chartService = new ChartService(httpClient);
+ *
+ * // Get hourly chart data for last 24 hours
+ * const now = Math.floor(Date.now() / 1000);
+ * const oneDayAgo = now - (24 * 60 * 60);
+ * const chart = await chartService.getChart({
+ *   tokenName: 'mytoken',
+ *   from: oneDayAgo,
+ *   to: now,
+ *   resolution: 3600
+ * });
+ * ```
+ */
+export declare class ChartService extends BaseService {
+    constructor(http: HttpClient, debugMode?: boolean);
+    /**
+     * Get historical chart data
+     *
+     * Retrieve OHLC (Open, High, Low, Close) candlestick data for token price history.
+     * Data is aggregated at the specified resolution interval.
+     *
+     * @param options Chart fetch options
+     * @returns Promise resolving to chart data with candlesticks
+     *
+     * @example
+     * ```typescript
+     * // Get hourly data for last 24 hours
+     * const now = Math.floor(Date.now() / 1000);
+     * const oneDayAgo = now - (24 * 60 * 60);
+     * const chart = await chartService.getChart({
+     *   tokenName: 'anime',
+     *   from: oneDayAgo,
+     *   to: now,
+     *   resolution: 3600
+     * });
+     * console.log(`Got ${chart.dataPoints.length} candlesticks`);
+     *
+     * // Get minute-level data for 1 hour
+     * const oneHourAgo = now - 3600;
+     * const minuteChart = await chartService.getChart({
+     *   tokenName: 'anime',
+     *   from: oneHourAgo,
+     *   to: now,
+     *   resolution: 60
+     * });
+     * ```
+     */
+    getChart(options: GetChartOptions): Promise<ChartResult>;
+}
+//# sourceMappingURL=ChartService.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ChartService.d.ts","sourceRoot":"","sources":["../../src/services/ChartService.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAMH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAGhD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAG5C;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,+BAA+B;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,oBAAoB;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,oBAAoB;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,6BAA6B;IAC7B,QAAQ,EAAE,MAAM,CAAC;IACjB,8BAA8B;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,uBAAuB;IACvB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,kCAAkC;IAClC,SAAS,EAAE,MAAM,CAAC;IAClB,qCAAqC;IACrC,IAAI,EAAE,MAAM,CAAC;IACb,mCAAmC;IACnC,EAAE,EAAE,MAAM,CAAC;IACX,0CAA0C;IAC1C,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,uCAAuC;IACvC,UAAU,EAAE,cAAc,EAAE,CAAC;IAC7B,sCAAsC;IACtC,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,YAAa,SAAQ,WAAW;gBAC/B,IAAI,EAAE,UAAU,EAAE,SAAS,GAAE,OAAe;IAIxD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACG,QAAQ,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,WAAW,CAAC;CA8I/D"}

package/dist/services/ContentFlagService.d.ts

@@ -0,0 +1,218 @@
+/**
+ * Content Flag Service
+ *
+ * Service for managing content flags/reports on streams, chat messages, and comments.
+ *
+ * Two-tier system:
+ * - Chat/Comment: One-click flag (reason optional) - reviewed by Owner/Moderator
+ * - Stream: Modal required (reason required) - reviewed by Admin only
+ *
+ * @module ContentFlagService
+ * @since 5.8.0
+ */
+import type { JwtAuth } from '../auth/JwtAuth';
+import type { ActionFlagOptions, ActionFlagResult, CreateFlagOptions, CreateFlagResult, DismissFlagOptions, DismissFlagResult, FlagListResult, ListFlagsOptions, ListGlobalFlagsOptions } from '../types/content-flag.dto';
+import type { HttpClient } from '../utils/http';
+import { StreamTokenServiceBase } from './StreamTokenServiceBase';
+/**
+ * Service for managing content flags and reports
+ *
+ * @example
+ * ```typescript
+ * // Create a flag on a chat message (one-click)
+ * const result = await sdk.flags.createFlag({
+ *   tokenName: 'mytoken',
+ *   contentType: ContentType.CHAT_MESSAGE,
+ *   contentId: 'msg-123',
+ *   reportedUserAddress: 'eth|abc...',
+ * });
+ *
+ * // List pending flags for review
+ * const flags = await sdk.flags.listFlags({
+ *   tokenName: 'mytoken',
+ *   status: FlagStatus.PENDING,
+ * });
+ *
+ * // Take action on a flag
+ * await sdk.flags.actionFlag({
+ *   flagId: 1,
+ *   action: FlagAction.DELETE_AND_BAN,
+ * });
+ * ```
+ */
+export declare class ContentFlagService extends StreamTokenServiceBase {
+    /**
+     * Creates a new ContentFlagService instance
+     *
+     * @param http - HTTP client for making requests
+     * @param adminApiKey - Optional admin API key for elevated access
+     * @param jwtAuth - Optional JWT authentication manager
+     * @param debugMode - Enable debug logging
+     */
+    constructor(http: HttpClient, adminApiKey?: string, jwtAuth?: JwtAuth, debugMode?: boolean, userApiKey?: string);
+    /**
+     * Create a content flag/report
+     *
+     * For chat messages and comments, only contentType/contentId/reportedUserAddress are required.
+     * For streams, reason is also required.
+     *
+     * @param options - Flag creation options
+     * @returns Created flag data
+     * @throws Error if not authenticated or validation fails
+     *
+     * @example
+     * ```typescript
+     * // One-click flag on chat message
+     * const result = await sdk.flags.createFlag({
+     *   tokenName: 'mytoken',
+     *   contentType: ContentType.CHAT_MESSAGE,
+     *   contentId: 'msg-123',
+     *   reportedUserAddress: 'eth|abc...',
+     * });
+     *
+     * // Flag with optional reason/details
+     * const result = await sdk.flags.createFlag({
+     *   tokenName: 'mytoken',
+     *   contentType: ContentType.COMMENT,
+     *   contentId: 'comment-456',
+     *   reportedUserAddress: 'eth|abc...',
+     *   reason: FlagReason.SPAM,
+     *   details: 'User is posting spam links',
+     * });
+     *
+     * // Stream report (reason required)
+     * const result = await sdk.flags.createFlag({
+     *   tokenName: 'mytoken',
+     *   contentType: ContentType.STREAM,
+     *   contentId: 'stream-789',
+     *   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
+     *
+     * With the unified /v1/flags endpoint (v6.1.0+), tokenName is now a query parameter
+     * instead of a path parameter. Non-overseers MUST provide tokenName.
+     *
+     * @param options - List options with filters (tokenName required)
+     * @returns Paginated list of flags
+     * @throws Error if not authorized
+     *
+     * @example
+     * ```typescript
+     * // List all pending flags
+     * const result = await sdk.flags.listFlags({
+     *   tokenName: 'mytoken',
+     *   status: FlagStatus.PENDING,
+     * });
+     *
+     * // List flags by content type with cursor-based pagination
+     * const result = await sdk.flags.listFlags({
+     *   tokenName: 'mytoken',
+     *   contentType: ContentType.CHAT_MESSAGE,
+     *   pageSize: 50,
+     * });
+     *
+     * // List flags from a specific reporter
+     * const result = await sdk.flags.listFlags({
+     *   tokenName: 'mytoken',
+     *   reporterAddress: 'eth|abc...',
+     * });
+     * ```
+     */
+    listFlags(options: ListFlagsOptions): Promise<FlagListResult>;
+    /**
+     * List ALL flags globally across all tokens
+     *
+     * This is for overseers and admins to view flags across the entire platform.
+     * Use listFlags() for token-specific flag lists.
+     *
+     * With the unified /v1/flags endpoint (v6.1.0+), overseers can call this
+     * without a tokenName to see ALL flags. Non-overseers should use listFlags()
+     * and provide a tokenName.
+     *
+     * @param options - List options with filters (all optional)
+     * @returns Paginated list of flags
+     * @throws Error if not authorized (Admin API key or Overseer JWT required)
+     *
+     * @example
+     * ```typescript
+     * // List all pending flags globally
+     * const result = await sdk.flags.listGlobalFlags({
+     *   status: FlagStatus.PENDING,
+     * });
+     *
+     * // Filter by token name
+     * const result = await sdk.flags.listGlobalFlags({
+     *   tokenName: 'mytoken',
+     *   status: FlagStatus.PENDING,
+     * });
+     *
+     * // Filter by reporter and reason
+     * const result = await sdk.flags.listGlobalFlags({
+     *   reporterAddress: 'eth|abc...',
+     *   reason: FlagReason.SPAM,
+     * });
+     * ```
+     */
+    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
+     *
+     * @example
+     * ```typescript
+     * const result = await sdk.flags.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
+     *
+     * @example
+     * ```typescript
+     * // Delete the flagged content
+     * const result = await sdk.flags.actionFlag({
+     *   flagId: 123,
+     *   action: FlagAction.DELETE_CONTENT,
+     * });
+     *
+     * // Ban the user
+     * const result = await sdk.flags.actionFlag({
+     *   flagId: 123,
+     *   action: FlagAction.BAN_USER,
+     * });
+     *
+     * // Delete content and ban user
+     * const result = await sdk.flags.actionFlag({
+     *   flagId: 123,
+     *   action: FlagAction.DELETE_AND_BAN,
+     * });
+     * ```
+     */
+    actionFlag(options: ActionFlagOptions): Promise<ActionFlagResult>;
+}
+//# sourceMappingURL=ContentFlagService.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ContentFlagService.d.ts","sourceRoot":"","sources":["../../src/services/ContentFlagService.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAI/C,OAAO,KAAK,EACV,iBAAiB,EACjB,gBAAgB,EAChB,iBAAiB,EACjB,gBAAgB,EAChB,kBAAkB,EAClB,iBAAiB,EAEjB,cAAc,EACc,gBAAgB,EAC5C,sBAAsB,EAAC,MAAM,2BAA2B,CAAC;AAQ3D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEhD,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAElE;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,qBAAa,kBAAmB,SAAQ,sBAAsB;IAC5D;;;;;;;OAOG;gBAED,IAAI,EAAE,UAAU,EAChB,WAAW,CAAC,EAAE,MAAM,EACpB,OAAO,CAAC,EAAE,OAAO,EACjB,SAAS,GAAE,OAAe,EAC1B,UAAU,CAAC,EAAE,MAAM;IAKrB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAwCG;IACG,UAAU,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,gBAAgB,CAAC;IA6BvE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCG;IACG,SAAS,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,cAAc,CAAC;IAyBnE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;IACG,eAAe,CAAC,OAAO,GAAE,sBAA2B,GAAG,OAAO,CAAC,cAAc,CAAC;IA0BpF;;;;;;;;;;;;;;OAcG;IACG,WAAW,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAgB1E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;IACG,UAAU,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,gBAAgB,CAAC;CAexE"}